python基本语法

Python基础语法

1、Python的数据类型

int、bool、float、complex、str、list、tuple、set、dict（ps:其中str、list、tuple可以看作序列）。

2、基础函数

bool():0,’’,[],{},set(),None均为Flase
id():获取内存地址，默认展示十进制
type():获取数据的类型
oct():八进制的转化
int():十进制的转化
hex():十六进制的转化
bin():二进制的转化
0b:代表二进制数
0o:代表八进制数
0x：代表十六进制数

#bool()函数的使用：
print(bool())
print(bool(False))
print(bool(True))#为True
print(bool(''))
print(bool(0))
print(bool([]))
print(bool({}))
print(bool(None))
#type（）获取函数的类型
print(type(None))
#oct():八进制的转化
print(oct(10))
#int():十进制的转化
print(int(0x12))
#hex():十六进制的转化
print(hex(0b1010))
#bin():二进制的转化
print(bin(10))

3、基本类型的基本使用之str（不可变类型）

str：可以使用单引号，双引号，三引号
转义字符：
print()函数会解析转义字符当一个字符串前面加一个r,就是原样输出
转义字符：特殊字符：不能看见与语言语法有冲突的字符

#转义字符：\,print()函数会解析转义字符
print('\r\nwgs')
print(r'\r\nwgs')#当一个字符串前面加一个r,就是原样输出
print("wgs")
print('''wgs''')
print('\n,\',\t,\r')

字符串的基本操作：
1、+：拼接字符串
2、*：重复次数

#+：拼接字符串
print('hell0'+"world")
#*：重复次数
print(3*'hellp')

3、[n]：用于访问字符串里的任意单个字符，若为负数则反向从末尾取值

#[n]用于访问字符串里的任意单个字符，若为负数则反向从末尾取值
a='1234adsada'
print(a[1])
#下标从0开始
print(a[-1])#负数下标从-1开始

4、[n:m]：获取字符串的一组字符,截取n到m-1的一组字符，
4.1若m为负数，则m表示步长
4.2若m不给值，则截取到最后
4.3若n不给值，则从0为开始取
4.4若n为负值，m不给值，则从末尾去n个字符
(PS:总结，n或m，有一个为负数，则需要把负数转化为length+n或length+m，然后在进行取值。)

 b='ms tang dr is a page'
 #4.1若m为正数，则m表示步长，
 print(b[0:2])
 #0表示索引位置，2表示步长
 #若m为负数，则m表示从后面几位开始取；相当于print(b[0:length-2]),length为字符串长度。
 print(b[0:-2])
 #4.2若m不给值，则截取到最后，
 print(b[0:])
 #4.3若n不给值，则从0为开始取
 print(b[:4])
 #4.4若n为负值，m不给值，则从末尾取n个字符
 print(b[-2:])
 #总结，n或m，有一个为负数，则需要把负数转化为length+n或length+m，然后在进行取值。

4、基本类型的基本使用之tuple、list、set、dict

4.1、tuple类型（不可变类型）

元组（），使用小括号（‘1’,2,True）
+：列表拼接
*：重复

#tuple类型
at=('1',2,True)
bt=('12')
#为str类型
bt=('12',)
#为tuple类型
print(type(bt))
print(at+bt)
#tuple只能跟tuple类型进行拼接
print(at*3)
#列表与元组嵌套

ps：1.元组里面可以有列表，列表里面可以有元组
ps：2.type((1)),type((‘1’)),输出类型不为元组原因：（）解析为表达式
ps：type((1),),type((‘1’),),输出tuple
ps：type(())为tuple

4.2list类型（可变类型）

嵌套列表，list类型：[‘1’,2,True,‘world’,[‘1’,1]],列表中还有列表
列表取值[]：list[n],list[n,m]与字符串截取类似，list[n]取到的是元素，list[n,m]取的还是列表。
+：列表拼接
*：重复
ps：其中str、list、tuple可以看作序列。操作差不多。
ps：序列：可以使用in,not in逻辑运算符；len,max min函数的使用比较的是ascll的值，只有类型相同时才能比较；ord（）函数取单个字符ascll的值。

a='wgs'
at=('1',2,True)
al=['1',2,False]
#可以使用in,not in逻辑运算符；
print('w'in a)
print(True in at)
print(2in al)
#len,max min函数的使用比较的是ascll的值，（只有类型相同时才能比较）；#比较首字母的ascll值，如果相同则依次比较
print(len(a))
print(len(at))
print(len(al))
print(max(a))
print(max(at))
print(max(al))
print(min(a))
print(min(at))
print(min(al))
#ord（）函数取单个字符ascll的值

4.3set类型（可变类型）

set类型{}，里面没元素时，为dict类型;定义空集合的方法set()。
特点：无序的，不可重复的。
-：求两个集合的差集
&：求交集
|：求并集

#set的定义
asa,asb={1,2,34,4},{1,2,3}
print(asa)
print(asb)
#-：求两个集合的差集，以前者为准
print(asa-asb)
#&：求交集
print(asa&asb)
#|：求并集
print(asa|asb)

ps：可以使用in,not in逻辑运算符，len,max min函数的使用比较的是ascll的值，只有类型相同时才能比较。

4.4dict类型（可变类型）

dict类型，有key跟value,也是集合。key必须为不可变类型:可以为int float,str,bool,tuple，即值对应的地址不可变。value:可以为任意类型。

#定义一个字典
ad={1:'12',2:'234'}
print(ad)
#更新集合，没有的往里面加
ad.update({'one':4.5,'four':9.3})

5、变量与运算符

5.1变量

1.变量不需要定义=赋值符号，首字母不能为数字，不能有$,*等特殊字符，特殊字符不能定义。
2.int,str,tuple为不可变；list,set,dict为可变。
3.id()函数显示某个变量在内存里的地址

5.2运算符

1.算数运算符：
+，-，//，/，%，**，*
ps：//求的是熵，%求的是余数，/求的是值
2.赋值运算符：=，ps：不支持自增与自减。
3.比较运算符：返回一个bool值，ps：b=1b+=b>=1得：b=2

#比较运算符
b=1
print(b>1)
b+=b>=1 #b>=1为ture,返回1;b=b+1,得b=2。ps:比较运算符#优先级大于赋值运算符
print(b)#b的值为2

4.比较运算符：and or not ps：[1]or[]得：[1]1and2得：22and1得：1，计算机读指令的顺序。

#比较运算符，计算机读指令的顺序。
print([1]or[]) #结果为[1]
print([]or[1]) #结果为[1]
print(1and2)#结果为2
print(2and1)#结果为1

5.位运算符：&按位与|按位或^按位异或~按位取反>>无符号左移<<无符号右移转为二进制数进行计算。

#&按位与
print(2|1)
#|按位或
print(2&1)
#^按位异或
print(1^2)
#相同则为0，相反则为1 
#~按位取反
print(~1)

6.成员运算符：in,not in一个元素是否在一个列表中，返回的是bool;字典dict是针对key进行判断的。

s6=(1,2,'1',3)
for s in s6:
	print(s)
	s=2
	if s not in s6:
		print(s)
	elif s==2:
		print(str(s)+"怎么样了")
	else:
		pass
#字典dict是针对key进行判断的。
sm4={1:2,2:1,'3':1}
for s in sm4:
	print(s)
	print(sm4.get(s))

7.身份运算符：is,is not(涉及到对象)返回的是bool==比较的是值相等，is比较的是内存值相等。

#可变与不可变类型
ais='wgs'
bis='wgs'
bbis={1,2}
aais={1,2}
print(bool(ais is not bis))
print(bool(aais is bbis))
#isinstance判断aais的类型，返回bool值，可以判断子类
print(isinstance(aais,set))

ps：isinstance(a,str):用于判断a的类型，返回bool值；第二个参数可以是一个元组;;type()函数不能判断子类；isinstance可以。
ps:对象的三大特征：值(value)，类型（type），身份（id）。

6、循环&分支

6.1循环

1.递归时使用while，或已知目标，while后面可以接else语句。

#while 
a=1
sum=0
while a in range(0,10):
	sum+=a 
	a+=1
else:
	print('pass前')
	pass 
print(sum)

2.for循环，，，for后面可以接else，，，，，，break，continue的使用跟Java一样;当循环没有正常执行完是不会执行else的内容
ps：print()为print(a,’\n’)。
ps：for a in range(1,10,2):#a咋0到10之间
ps：for a in range(10,1,-2):#a咋0到10之间序列的切片取值

#for循环
ad={1:'2',True:'m','3':[1,2,3,4,5,6],(1,23,3):123}
for a in ad:
	value=ad[a]
	if type(value)==type([]):
	for d in value:
		print(d)
		break 
	else:
		print(value)
		continue

6.2分支

1.if\elif\else\pass的使用。

s6=(1,2,'1',3)
for s in s6:
	print(s)
s=2
if s not in s6:
	print(s)
elif s==2:
	print(str(s)+"怎么样了")
else:
	pass

7、组织管理

7.1组织划分

1.包：指目录名，每个包下面必须要有一个_init_.py文件。
2.模块：指包下面的单个.py文件。
3.类：指模块文件下，定义的类。
4.函数与变量：类或模块内定义的基本元素。

7.2模块导入

1.import后面接module名。
ps：导入某个模块。
2.from module(模块名)
import（类，函数，以及变量）
3.号的使用，使用导入模块内所有的元素
ps：导入Python包时会自动运行_init_.py代码；包跟模块的导入，不会重复导入；注意循环引入问题，导入会执行模块里代码。

8、函数

8.1函数的特点

1.功能性，避免重复代码。
2.允许有多个返回值。

8.2分类（按入参）

1.关键字参数：调用时add(x=1,y=2),可读性强，赋值是无需按顺序给参。
2.默认参数：定义时def add(x,y=1)，这样调用时，可以使用add(x)或add(x,y)。

9、类、类变量、类方法、实例变量、实例方法、静态方法，以及成员可见性

9.1类的定义

9.2类变量

9.3类方法

9.4实例变量

9.5实例方法

9.6静态方法

9.7成员可见性

10、正则表达式以及装饰器

10.1正表达式相关函数

1.re模块
ps：re.findall(’’,re.I|re.S),re.sub()

#正则表达式的使用
#1.转义字符以及部分字符的含义w s.d 
import re
#d匹配所有数字[0-9]；
str2='1243sqswq534534'
d=re.findall('^\d*$',str2)
print(str2)
#re.sub()
s=re.sub('\d+','|',str2)
#.匹配所有
str2='124dsafvsaf rfwaf 422r3/-*/+'
d=re.findall('^.*$',str2)
print(d)
#s匹配所有空字符(包括回车，空格)
str2=''
d=re.findall('^\s*$',str2)
print(d)
#w匹配[a-zA-Z0-9_]
str='wgs3432532SADAD_'
d=re.findall('^\w*$',str)
print(d)
print(type(d))

2.search()、match()、group()

#re.search(),返回第一个匹配到的字符串,如果匹配失败，则返回None
d='qafgr3fuedsbvc3u85'
a=re.search('.*(\d).*(\d+)',d)
print(a)
print(a.group())
print(a.groups())
print(a.group(1))
print(a.group(2))
#re.match(),要求必须从字符串的开头进行匹配，如果字符串的开头不匹配，整#个匹配就失败了；如果匹配失败，则返回None 
b=re.match('.*(\d).*(\d+)',d)
print(b)
print(b.group())
print(b.groups())
print(b.group(1))
print(b.group(2))
print(dir(re))

3.字符集[]，里面字符为，或关系

#字符集[]，里面字符为，或关系
str='wwghdwe'
a=re.sub('w[ge]','123',str)
print(a)

4.数量词{}，贪婪与非贪婪；
ps：加一个问号变成非贪婪{1,33}?默认为贪婪匹配；加上？为非贪婪匹配：

b=re.match('.*?(\d).*?(\d+)',d)
print(b)
print(b.group())
print(b.groups())
print(b.group(1))
print(b.group(2))
print(dir(re))

5.？*+
6.边界符^$7.组()里面字符为，且关系

10.2装饰器

#装饰器的使用，实现异步
from threading import Thread 
from time import sleep 

def async(f):
	def wrapper(*args,**kwargs):
		thr=Thread(target=f,args=args,kwargs=kwargs)
		thr.start()
		return wrapper 


def myd(f):
	def wrapper(*args,**kwargs):
		print("hello start")
		f(*args,**kwargs)
		print("hello end")
		return wrapper


@async 
def A():
	sleep(10)
	print("a function")

@myd 
def B(x,y='1'):
	print("b function"+x+y)

A()
B('1')

11、枚举以及高级用法

11.1枚举

1.枚举相对类，具有不可变性，标签不重复性
2.枚举可以使用for进行遍历
3.枚举的值，枚举的名称，枚举的类型
4.当值相同时，会出现别名机制
5.IntEnum,值不能有重复，并且只能为数字

11.2高级用法

1.lambda表达式
2.filter

#filter函数的使用过滤list(b)只能取一次结果
a=[0,1,2,3,4,5,6]
b=filter(lambdax:x>2,a)
b=filter(None,[0,1,2,3,4,5,6])
print(type(b))
#print(type(list(b)))
print(list(b))
x=2
print(x%5)
print(list(range(0,101)))
print(list(filter(lambdax:x%5,range(0,101))))

3.map

#map函数的使用映射
a=[1,2,3,4,5]

def my(x):
	return x*x
 
print(map(my,[1,2,3,4,5,6,7,8,9]))
print(list(map(my,[1,2,3,4,5,6,7,8,9])))
b=map(my,a)
print(type(b))
for x in b:
	print(x)
	
c={1,2,3,4,5,6,6,7}
print(c)

d=map(lambda x,y:x**y,c,c)
print(list(d))
for y in d:
	print(y)
	
f=map(lambda x,y:x**y,c,[1,2])
for y in f:
	print(y)
	

4.reduce

#reduce的使用
#reduce函数的使用对集合进行迭代处理
from functools import reduce
 
a=[1,2,3,4,5,6]
b=reduce(lambda x,y:x*y,[1,2,3,4,5,6])
print(type(b))
print(b)

5.列表推倒式

#列表推倒式
a=[11,2,3,4,5,6]
b=[key*3for key in a if key%3==0]
print(b)

6.字典推倒式

#字典推倒式
c={4:'xs',2:'csc',3:'scvsvc'}
d={key:valuefor key,value inc.items()if value=='xs'}
print(d)
d={key*value for key,value inc.items()if value=='xs'}
print(d)

7.字典映射代替switch case语法，注：Python不支持switch语法

#字典映射代替switch case语法，注：Python不支持switch语法
a={0:'hh',1:'scs',2:'ssc'}#此方法当字典中没有对应key时会报错
b=1
print(a[b])
#定义function 
def hh():
	print('hh')

def hhdefault(m):
	print('hhdefault')
	print(m)
	
def scs():
	print('scs')

def ssc():
	print('ssc')
	
c={0:hh,1:scs,2:ssc}
d=2
#支持默认
c.get(4,hhdefault)(12)

8.闭包，返回的函数以及函数所在的环境

#闭包函数返回的函数，指的是函数体以及函数的运行环境
def func():
	x=20
	def func2(y):
		nonlocal x #必须声明x不为局部变量，否则会显示未定义
		print(x**2+y)
		x+=1
		return func2 

f=func()
f(12)
f(12)
f(12)

ps：一切皆对象，如将函数赋给某个变量，将函数当做返回值。
ps：支持函数式编程。
ps：闭包：函数+环境变量，形成封闭环境，，在一个函数返回另一个函数式返回的是闭包，，保存的是函数运行现场。

12、集合推倒式

对象存在并不一定是True__len__,,,__bool__

13、异常