python中常见的语法基础大全1.0

1.输入与输出

print:输出,将hello world 显示在控制台上

print('hello world')

input 输入，从键盘中输入的字符存到变量a中

a = input('请输入一个数')

2.变量与常见的数据类型

定义一个变量

a = 1

数据类型

数字类型（包括整型(int)，浮点型(float)）

a = 10b = 100c = 1.25d = 1.26

字符串(str)

str_a = 'abcd'str_b = 'cdefg'

布尔类型(Bool)

bool_a = Truebool_b = False

列表(list)

list_a = [1,2,3,4]list_b = ['a','b','c']list_c = [1,'a',2,'b',3]

元组(tuple)

tuple_a = (1,2,3,4,5)

字典(dict)

dict_a = {'name':'zz','age':20}

3.常见的运算符

算术运算符

运算符	描述	实例
+	加	1+1=2
-	减	2-1=1
*	乘	1*2=2
/	除	2/2=1.0
%	取模：返回除法的余数	6%4=2
//	向下取整，取商	6%4=1
**	次方	2**3 = 8

比较运算符

比较运算符	说明
a > b	大于，如果前面的值大于后面的值，则返回 True，否则返回 False。
a < b	小于，如果前面的值小于后面的值，则返回 True，否则返回 False。
a == b	等于，如果两边的值相等，则返回 True，否则返回 False。
a != b	不等于（等价于数学中的 ≠），如果两边的值不相等，则返回 True，否则返回 False。
a >= b	大于等于（等价于数学中的 ≥），如果前面的值大于或者等于后面的值，则返回 True，否则返回 False
a <= b	小于等于（等价于数学中的 ≤），如果前面的值小于或者等于后面的值，则返回 True，否则返回 False。
a is b	判断两个变量所引用的对象是否相同，如果相同则返回 True，否则返回 False。
a is not b	判断两个变量所引用的对象是否不相同，如果不相同则返回 True，否则返回 False。

逻辑运算符

运算符	含义	说明
and	逻辑与运算，等价于数学中的“且”	a and b ，当a,b两个表达式都为真时，结果才为真，否则为假
or	逻辑或运算，等价于数学中“或”	a or b ，当a,b两个表达式都为假时，结果才为假，否则为真
not	逻辑非运算，等价于数学中“非”	not a,当a为真时结果为假；a为假时结果为真

成员运算符

运算符	描述	案例
in	如果在指定的序列中找到值返回 True，否则返回 False。	1 in [1,2,3]，返回True
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	3 not in [2,3,4],返回False

运算符的优先级：多个运算符，同时出现，先执行哪个

运算符(优先级依次降低)	描述
**	指数 (最高优先级)
~ + -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
*  /  %  //	乘，除，取模和取整除
+ 1	加法减法
>> <<	右移，左移运算符
&	位 'AND'
^ |	位运算符
<=   <  >  >=	比较运算符
==    !=	等于运算符
=   %=   /=  //=     -=     +=   *=    **=	赋值运算符
is    is not	身份运算符
in not in	成员运算符
not or and	逻辑运算符

4.条件语句

if...else...：如果...那么

a = 2b = 3if a > b:    print('a大')else:    print('b大')

if...elif..elif..else:如果..否则如果...否则如果...否则

a = input('请输入一个数字')#类型转换，把字符串转成数字a = int(a)
#只会进入下面中的一个if a > 10: print('比10大')elif a > 20: print('比20大')else: print('比10小')

5.循环语句

for语句:挨个遍历可迭代对象中的每个数据

#i会输出0，1，2，3，4，5，6，7，8，9for i in range(0,10):    print(i)

while语句：满足条件就执行循环体

a = 1while a < 10: print(a) a = a + 1

continue:跳出某一次循环

for i in range(0,10):    if i == 3:        continue  print(i)#输出：0，1，2，4，5，6，7，8，9

break:跳出整个循环

for i in range(0,10): if i == 3: break print(i)#输出：0，1，2

6.字符串的常见操作

类型转换

str_a = '123'#字符串转整数int_a = int(str_a)  # 123
str_b = '123.1'#字符串转浮点数float_b = float(str_b)  #123.1
str_c = '2'#字符串转布尔类型bool_c = bool(str_c)  #True
str_d = '1234'#字符串转列表list_d = list(str_d) #['1','2','3','4']

根据索引取值

str_a = 'abcde'a = str_a[0] #取字符串ab = str_a[1] #取字符串b

字符串的拼接

a = 'abc'b = 'def'c = a + bd = a * 2print(c)print(d)#输出'abcdef''abcabc'

遍历取值

str_a = 'abcde'#通过索引挨个取值for i in range(len(str_a)): print(str_a[i])
#直接挨个取值 for j in str_a: print(j)

格式化字符串

format:推荐

a = 'zz'b = 18print('我的名字叫{},今年{}岁了'.format(a,b))

字符串的切片

str_a = 'abcdefghi'#从下标为0开始取，到下标为7结束，每隔2个数取一个值a = str_a[0:8:2] #'aceg'
#从开头取到下标为4结束b = str_a[:5] #'abcde'
#从下标为5取到结束c = str_a[5:] #'fghi'
#如果步长为负值，第一位表示最后的值，第二位表示开始的值，然后从右往左每隔一段距离取值d = str_a[::-1] #'ihgfedcba'

字符串常见方法

find:find()方法返回该元素最小索引值（找不到返回-1）

s = 'abcdeeff'print(s.find('eeff'))#输出4

index()：index()方法返回该元素最小索引值（找不到元素会报错）

s = 'abcdeeff'print(s.index('eeff'))#输出4

startswith(): startswith() 方法如果字符串以指定值开头，返回True,否则返回False

s = 'abcdeeff'print(s.startwith('abc'))#True
print(s.startwith('cba'))#False

endswith():endswith() 方法如果字符串以指定值结束，返回True,否则返回False

s = 'abcdeeff'print(s.endwith('ff'))#True
print(s.endwith('ee'))#False

count():count() 方法返回指定值在字符串中出现的次数

s = 'abcdeeff'print(s.count('e'))#输出2

upper():upper()方法将字符串全部转为大写

s = 'abcdeeff'print(s.upper())
#输出ABCDEEFF

lower():lower()方法将字符串全部转为小写

s = 'ABCDEFG'print(s.lower())
#输出abcdefg

split():split()方法以指定字符分割字符串，并返回列表

s = 'a-b-c-d-e-f'print(s.split('-'))
#输出['a', 'b', 'c', 'd', 'e', 'f']

strip():strip()方法删除字符串两端的空格

s = '  abcdefg    '   print(s.strip())
#输出abcdefg

replace():replace()方法以指定内容替换掉被指定内容（默认替换全部，可指定替换次数）

s = 'I like python,I like world' print(s.replace('I','You',1)) #只替换一次print(s)
#输出You like python,I like worldI like python,I like world
#生成了新的字符串，原字符并不发生变化

join() ：join()方法获取可迭代对象中的所有项目，并将它们连接为一个字符串。必须将字符串指定为分隔符

s = ['1','2','3','4','5']  print('-'.join(s))
#输出1-2-3-4-5
#注意s列表中的要是字符串类型

7.列表常见操作

定义一个空列表

a = []a = list()

根据索引取值

a = ['a','b','c']b = a[0]c = a[1]d = a[2]

删除某个位置的值

a = ['a','b','c']del a[0]print(a)
#输出['b', 'c']

遍历整个列表

a = ['a','b','c','d','e']#通过索引遍历for i in range(len(a)):    print(a[i])#直接遍历取值for j in a:    print(j)

列表推导式

常用推导式

l = [i for i in range(0,10)]#可以转换成如下的程序l = []for i in range(0,10): l.append(i)

带if的列表推导式

l = [i for i in range(0,10) if i > 5]#可以转换成如下程序l = []for i in range(0,10):    if i > 5:      l.append(i)

多个for的嵌套

l = [(i,j) for i in range(0,5) for j in range(6,10)]#可以转换成如下程序l = []for i in range(0,5): for j in range(6,10): l.append((i,j))print(l)

列表的常见方法

append():给列表末尾添加一个元素

a = [1,2,3,4]a.append(5)print(a)
#输出[1,2,3,4,5]

insert():向指定位置添加一个元素

a = [1,2,3,4,5]a.insert(2,8)print(a)
#输出[1, 2, 8, 3, 4, 5]

extend():合并两个列表中的元素

a = [1,2,3,4,5]b = [6,7,8,9,10]a.extend(b)print(a)
#输出[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

pop()：移除列表中最后一个元素，并返回移除的那个元素

a = [1,2,3,4,5]b = a.pop()print(a)print(b)
#输出[1, 2, 3, 4]5

sort():列表按照ASCLL值从小到大排序

a = [2,3,4,1,6,3,5,8,1]b = a.sort()print(a)
#输出[1, 1, 2, 3, 3, 4, 5, 6, 8]

index():查找元素第一个出现的位置，返回下标值，找不到则报错

a = [2,3,4,1,6,3,5,8,1]print(a.index(1))
#输出3

reverse():将列表进行翻转

a = [2,3,4,1,6,3,5,8,1]a.reverse()print(a)
#输出[1, 8, 5, 3, 6, 1, 4, 3, 2]

remove():根据传入的元素参数，移除列表中第一次出现的元素 ,找不到则报错

a = [2,3,4,1,6,3,5,8,1]a.remove(1)print(a)
#输出[2, 3, 4, 6, 3, 5, 8, 1]

count():统计元素出现的次数

a = [2,3,4,1,6,3,5,8,1]b = a.count(1)print(b)
#输出2

clear():清空列表中的元素

a = [2,3,4,1,6,3,5,8,1]a.clear()print(a)
#输出[]

copy():拷贝列表，会返回一个新的列表

a = [2,3,4,1,6,3,5,8,1]b = a.copy()print(b)
#输出[2, 3, 4, 1, 6, 3, 5, 8, 1]

8.字典相关操作

新建一个字典

dic = {}dict_a = dict()

给字典添加键值对

dic = {}dic['name'] = 'zz'dic['age'] = 18dic['height'] = 180.6dic['friend'] = ['a','b','c']

删除字典中的键值对

dic = {'name':'zz','age':18,'height':20}del dic['name']

修改字典中键对应的值

dic = {'name':'zz','age':18,'height':20}dic['name'] = 'jay'

遍历字典

#遍历取出字典中的键值对dic = {'name':'zz','age':18,'height':20}for k,v in dic.items(): print(k,v)
#遍历取出字典中的键dic = {'name':'zz','age':18,'height':20}for k in dic.keys(): print(k)
#遍历取出字典中的值dic = {'name':'zz','age':18,'height':20}for v in dic.values(): print(v)

字典常见方法

将字典中的键转换成列表

dic = {'name':'zz','age':18,'height':20}l = list(dic.keys())print(l)#输出['name', 'age', 'height']

将字典中的值转换成列表

dic = {'name':'zz','age':18,'height':20}l = list(dic.values())print(l)#输出['zz', 18, 20]

update():合并两个字典

dic = {'name':'zz','age':18,'height':20}dic.update({'w':20})print(dic)#输出{'name': 'zz', 'age': 18, 'height': 20, 'w': 20}

9.函数相关

定义函数

#def:关键字#test:函数名#a,b:形式参数#return a + b:返回值def test(a,b): return a + b

调用函数

def test(a,b):    return a + b#函数调用，返回值存到变量s里面s = test(1,2)print(s)#输出3

函数参数相关

形式参数和实际参数

#定义时，a,b为形参def test(a,b): return a + b
#调用时1,2为实参s = test(1,2)print(s)

必传参数

#a,b为必传参数，调用时，必须传递两个值，否则报错def test(a,b):    return a + b
print(test(1,2))

默认参数

#默认参数必须放在必传参数的后面，c=3，只能放在必传参数a,b的后面，放前面则报错def test(a,b,c=3): return a + b + c
#不传，c默认为3print(test(1,2))#输出6
#传递，则使用传递的值print(test(1,2,5))#输出8

关键值参数:出现在函数调用时

def test(a,b,c=3,*d):    print(a,b,c)    return a + b + c
#不需要按照顺序传递，直接给参数指定值，这个就叫关键值参数test(b=5,a=2,c=8)

可变参数：不定长参数

*arg:接受任意多个实际参数

def test(a,b,*c): print(a) print(b) print(c)
#将1赋值给a,2赋值给b,剩下的实参以元组的形式赋值给ctest(1,2,3,4,5)
#输出12(3, 4, 5)

**kwargs:接收任意多个以关键字参数赋值的实际参数

def test(a,b,*c,**kwargs):    print(a)    print(b)    print(c)    print(kwargs)
#d=1,3=2,f=3，以字典的形式赋值给kwargstest(1,2,3,4,5,d=1,e=2,f=3)
#输出12(3, 4, 5){'d': 1, 'e': 2, 'f': 3}

匿名函数

# x,y为匿名函数的参数,x+y为返回值lambda x,y:x+y

10.作用域相关

全局作用域(G)，局部作用域(L)，闭包作用域(E),内置作用域(B)

#顶层模块中所有函数外创建的全局变量，此时的 a 就是全局作用域中的变量a = 1def test():    #存在嵌套函数中，为其外层作用域,此时的a就是inner的闭包作用域的变量    a = 2    def inner():        #在函数内部或lambda、类中的全局局部变量中，调用函数时才会创建，a此时为inner的局部作用域中的变量        a = 3    inner()test()

变量一般访问顺序:L->E->G->B

a = 1def test(): a = 2 def inner(): a = 3 print(a) inner()
test()#输出3
#======================a = 1def test(): a = 2 def inner(): print(a) inner()
test()#输出2
#========================a = 1def test(): def inner(): print(a) inner()
test()#输出1

修改不同作用域中的变量

global：声明修改全局作用域中的值

a = 1def test():    global a    #直接修改会报错    a += 1    def inner():        global a        a += 1        print(a)    inner()
test()#输出3

nonlocal:声明修改闭包作用域中的值

a = 1def test(): a = 2 def inner(): nonlocal a a += 1 print(a) inner()
test()#输出3