1. 编程号首页

python 菜鸟 教程_Python 入门

编程小号 • • 未分类

python 菜鸟 教程_Python 入门一、可以使用’\’来连接多行。但是有括号的则不需要a=b+\c+\da1=[‘a’,’b’]引号可以是单，双，三引号均可二、1.python有5个标准类型：数字，字符串，列表，元组，和字典2.字符串获取某字符串的一段字符串可以使用[头下标，尾下标]s=’abcde’s[1:5]#’bcde’s+’rrr’#字符串加法s#bcderrr3.列表：Python中使用最频繁的类型列表用[]标识，支持[]截取，从左开始从0，从右开始为-_python菜鸟教程

python

一、

  1. 可以使用’\’来连接多行。但是有括号的则不需要
a=b+\
  c+\
  d
a1=['a',
    'b']
  1. 引号可以是单，双，三引号均可

二、

1. python有5个标准类型：数字，字符串，列表，元组，和字典

2. 字符串

  1. 获取某字符串的一段字符串可以使用[头下标，尾下标]
s='abcde'
s[1:5]
# 'bcde'
s+'rrr'#字符串加法
s
#bcderrr

3. 列表：Python中使用最频繁的类型

  1. 列表用[]标识，支持[]截取，从左开始从0，从右开始为-1。列表内部支持字符，数字，字符串，甚至包含列表
  2. +为连接操作，*为输出n次
t=['a','b','c']
t1=[:1]
# t1=['a','b']
t2=['a',20,2.3,'name']

4. python元组

  1. 元组用()标识，内部元素用逗号分开，元组不能二次赋值，相当于只读列表
tuple1=('a',20,'name')
tuple1[1]=3300 #!!错误，不允许改变元组的值

5. python字典

  1. 是除列表外，最灵活的类型，字典可以通过键来存取。字典用{}来表示，由key和value组成
dict={ 
   }
dict['one']='I\'m one'
dict[2]='Two'
dict1={ 
   'name':'ruun','code':666,'dept':'sales'}
print(dict[2])# 'Two'

6. 数据类型转换

  1. 举例，其他类似
long(x)#x转换为长整数
str(x)#x转换为字符串

三、运算符

1.

  • %:返回除法的余数 3%2 -> 1
  • **：返回x的y次幂 10**2 -> 100
  • ‘//’：返回商的整数部分 9//2 ->4

2.

  • and,or,not 与，或，非

3. 判断是否在指定序列

  • in
  • not in

4. 身份运算符

  • is #判断两个标识符是否引用自一个对象
  • is not
a = 20
b = a
 
if ( a is b ):
   print "1 - a 和 b 有相同的标识"
else:
   print "1 - a 和 b 没有相同的标识"
 
if ( a is not b ):
   print "2 - a 和 b 没有相同的标识"
else:
   print "2 - a 和 b 有相同的标识"
 
# 修改变量 b 的值
b = 30
if ( a is b ):
   print "3 - a 和 b 有相同的标识"
else:
   print "3 - a 和 b 没有相同的标识"
 
if ( a is not b ):
   print "4 - a 和 b 没有相同的标识"
else:
   print "4 - a 和 b 有相同的标识"
#1 - a 和 b 有相同的标识
#2 - a 和 b 有相同的标识
#3 - a 和 b 没有相同的标识
#4 - a 和 b 没有相同的标识

四、

  1. python没有switch语句，判断多条需要elif;判断多个条件，可以使用or
if num>0 and num <10:
    print('1')
elif num==0:
    print('0')

五、循环语句

  1. while
    while (c<5):
        pass
    else:
        pass
  1. for
a=['a','b','c']
for i in a:
    print(i)# 'a' 'b' 'c'
for i in range(len(a))
    print(a[i])# 'a' 'b' 'c'

六、

  1. break,continue 语句与c++中作用相同，用于跳出循环
  2. pass语句为空语句，保持程序完整

七、字符串

  1. 字符串支持 in, not in 访问
  2. print输出时，格式化字符串或者数字
  3. 使用三引号，可实现所见即所得，不用再在内容内部使用转义字符
print ('I am %s and age is %d'%('Myy',18))
a='''I / % * '''
  • %s-字符串
  • %d-整数
  • %c-字符
  • %f-浮点数，可以指定小数点后精度

八 列表

  • 利用append更新列表

  • del删除列表某元素del list1[2]

  • 支持in,not in操作

  • 支持len()操作

  • list1[-1],表示倒数第一个元素

  • cmp(l1,l2)比较

  • len(l1)

  • max(l1)最大

  • min(l1)

  • list(seq)元组转为列表

  • list.append

  • list.count(obj)统计某个元素在list中出现次数

  • list.extend(seq)一次追加另一个序列的多个值

  • list.index(obj)找到该值并返回其索引

  • list.insert(index,obj)插入

  • list.pop[index=2])移除一个元素，默认是最后一个

  • list.remove(obj)移除某个值的第一个匹配项

  • list.reverse()反向表中元素

九、元组

  • 元组与列表类似，不同之处在于元组不可修改，元组使用()，而列表用[]
  • 元组中只包含一个元素时，需要在元素后面添加逗号。tuple=(50,)
  • 可以通过索引访问元组值，可以进行截取，组合，但是不能修改其中的值
  • 元组的某一个值不可以删除，但是允许del语句删除整个元组
t1=('a',3,'aaa')
t2=(4,)
t3=t1[2] #'aaa'
t4=t1+t2 # 'a',a,'aaa',4
del t4
print(t4) #报错！！
  • 元组的运算符:支持in 遍历；
len((1,2,3)) # 3
t1=(1,)+(3,4) # (1,3,4)
t2=('A')*4 #('A','A','A','A')
for x in t2: print(x)
  • 元素截取
L=('spam','Spam','SPAM')
L[2] #'SPAM'
L[-2] #'Spam'
L[1:] #'Spam','SPAM'
  • 元组内置函数
  • cmp(t1,t2) #比较
  • len(tuple)
  • max(tuple) 返回最大值
  • min(tuple)
  • tuple(seq) 将列表转为元组

十、字典

  • 字典值的访问，直接通过索引key
dict={ 
   'name':'Zara','Age':7,'Class':'First'}
print(dict['name'])
  • 字典里的内容可以通过key索引修改
  • 支持删除某一元素、清空字典、删除整个字典
dict={ 
   'Name':'nancy','Age':4,'Class':'First'}
del dict['Name'] #删除某一条目
dict.clear() #清空字典
del dict #删除字典
  • 字典内置函数
  • cmp(d1,d2)
  • len(d1)
  • str(d1) # 输出字典可打印的字符串表示
  • type(variable) #返回输入的变量类型
  • dict.copy()#返回一个字典的浅复制
  • dict.has_key(key)#如果键在字典里返回true,否则返回false
  • dict.items() #以列表返回可遍历的(键，值)元组数组
  • dict.update(d2)# 将d2的值更新到dict中
  • dict.values() #以列表返回一个字典所有的值
  • dict.keys() #以列表返回一个字典所有的键
  • pop(key[,defalut]) 删除字典给定键key所对应的值，返回被删除的值
  • popitem() 返回并删除字典最后一对键合值

十一、时间和日期

  • 这里只说操作，具体实现用到再看该链接
  • 获取当前时间
  • 获取格式化好的时间
  • 自定义格式化时间
  • 获取某月日历
import time 
t=time.locatime(time.time())
print(t)
# time.struct_time(tm_year=2016, tm_mon=4, tm_mday=7, tm_hour=10, tm_min=3, tm_sec=27, tm_wday=3, tm_yday=98, tm_isdst=0)
....

十二、

1. python没有值传递或者引用传递的定义，但是可分 可变对象和不可变对象。python的列表和字典就是可变对象，在函数内部修改后，函数外部也会随着修改，其他诸如字符串，数字等则不可变

def f1(a):
    a=110
def f2(list1):
    list1.append([1,2,3])
b=0
list2=['a',1]
print(f1(b))# 0
print(f2(list2))#['a',1,1,2,3]

2.关键字参数，可以不按照顺序来传入参数,但要保持关键字相同

def f1(name,age):
print('name: ',name)
print('age: ',age)

f1(age=19,name='M')
# name: M
# age: 19

3.默认值参数，没有输入则打印默认值

def f1(age=30,name):
print('name:',name)
print('age:',age)

f1(name='miki')
# 'name:' miki
# 'age:' 30
f1(age=50,name='Zara')
# 'name:' Zara
# 'age:' 50

4.不定长列表或字符，数字等；不定长字典*args,**kwarg

def f1(name,*list):
    print(name)
    for i in list:
        print(i)
a=['a','b','c']
f1(name='Zara',a)
f1(name='Amili',1,2)

#--------------
def f1(**kwarg):print(kwarg)
f1(x=1,y=3,name='A')
# {'x':1,'y':3,'name':'A'}

5.lambda表达式

  • 基本语法：lambda[arg1,agr2,…]:expression
sum=lambda arg1,arg2:arg1+agr2
print(sum(10,20))#30

6. 全局变量和局部变量

  • 注意定义的全局变量在函数内部变为，局部变量
total = 0 # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
   #返回2个参数的和."
   total = arg1 + arg2 # total在这里是局部变量.
   print "函数内是局部变量 : ", total
   return total
 
#调用sum函数
sum( 10, 20 )
print "函数外是全局变量 : ", total

十三、

  • import math后，调用其中的函数时需要match.sum(1,2)，加前缀
  • ‘from A import B’，使用同上B(a,a)or B.fun()
  • from A import*， 一次将所有A中内容引入

十四、

1. 读取键盘输入raw_input()、input()

两者区别就是input支持输入表达式进行计算

2. 文件的读写具体操作，用到时再参考该链接

str=raw_input("Input your words:")
print(str)
# Input your words: 111
# 111
str=('Input')
print(str)
# Input [x*4 for i in range(2)]
# [0,4]

十五、File操作

  1. open(file,mode=‘r’),必须搭配close();mode为打开模式

mode 参数有

  • x: 写模式，新建一个文件，如果该文件已经存在，则报错
  • +：打开文件，可读可写
  • r：只读形式，文件中指针放在文件开头
  • r+：读写文件，指针在文件开头
  • w：只写，如果文件已存在，则打开，并从头开始编辑，原有内容会被删除。如果该文件不存在，创建新文件
  • w+：读写，如果文件已存在，则打开，并从头开始编辑，原有内容会被删除。如果该文件不存在，创建新文件
  • a：追加文件，指针在文件尾。文件不存在则创建
  • a+：追加，可读可写，文件指针会在文件结尾
    *…以及一些二进制形式处理的模式
  1. file常用函数
  • f.flush() 刷新文件内部缓冲
  • f.close() 关闭文件
  • f.next() 返回文件下一行
  • f.readline() 读取整行，包括’\n’
  • f.readlines() 读取所有行，并返回列表
  • f.tell() 返回文件当前位置
  • f.writelines(sequences) 向文件写入一个序列字符串列表，需要自己手动加入每行的换行符

十六 python常用内置函数

  • abs() 绝对值
  • divmod(a,d) 输出除法结果的商和余数
  • enumerate() 将一个可遍历的数据对象，如列表，元组，组合为一个索引序列，同时给出数据和数据下标
>>>seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq):
...     print i, element
... 
0 one
1 two
2 three
  • math.pow() 求幂
import math
print(math.pow(3,0))# 1
print(math.pow(3,2))# 9
  • map(fun,iterable)用法1，根据提供的函数对指定序列做映射
  • map用法2，对某数据里的字符串进行字典式映射
# 1.
def f1(a):
    a*4
list2=map(f1,[1,2,3,4])
list3=map(lambda x:x*4,[1,2,3,4])
list4=map(lambda x,y:x*y,[1,2,3,4],[2,2,2,3])
# list2=[4,8,12,16]
# list3=[4,8,12,16]
# list4=[2,4,6,12]
# 2. 
MAP_SEX={ 
   'male':1,'female':0}
# Sex
# 0 male 
# 1 female
data.map(MAX_SEX)
# Sex
# 0 1 
# 1 0
  • eval()执行一个字符串表达式，并返回表达式的值
x=7
eval('x*3')
>>21
  • zip 将可迭代的对象作为参数，将对象中的元素打包为一个个元组，返回元组组成的列表
a=[1,2,2]
b=[4,5,6]
z=zip(a,b)
#c=[(1,4),(2,5),(2,6)]
  • set创建一个无序不重复元素集，可删除重复数据，还可进行交集，差集，并集操作等
  • id() 返回对象的内存地址
  • ‘sorted()’对列表内容进行排序，可以定义比较的规则
a=[3,4,1]
L=[('a',1),('c'.3),('e',0),('d',9)]
sorted(L,lambda x:x[1])#按照列表里的元素的第二个内容排序
#L=[('e',0),('a',1),('c'.3),('d',9)]

今天的文章python 菜鸟 教程_Python 入门分享到此就结束了，感谢您的阅读，如果确实帮到您，您可以动动手指转发给其他人。

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。
如需转载请保留出处：https://bianchenghao.cn/59138.html

赞 (0)
编程小号编程小号
0

相关推荐

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注