python笔记

python

翻译的方式有两种：

​ 编译：在程序运行之前进行翻译，翻译后会生成一个新的文件，后续每次运行都是执行这个翻译后的文件，因此执行效率要高一些 —— Java

​ 解释：在程序运行时翻译，每个语句都要执行的时候才会翻译，每次运行都需要翻译一次，因此执行效率相对来说要低一些 —— python

​ 解释型语言通常适用于：1.对运行速度要求不高(脚本，接口辅助开发等) 2.对跨平台(对操作系统需要兼容)有要求的场景

标准库：keyword 标准库

​ random标准库

​ random.randint — 随机整数

​ time 标准库

​ time.sleep — 延时函数

​ re标准库

​

第三方库：

pycharm使用：新建项目时，添加项目解释器

数据类型转换规则
    1）使用str()函数转为字符串，所有的数据类型都可以转成字符串
    2）使用int()/float()转为数值型，
        字符串里面的值如果是数字，就可以转为数值
        布尔值可以直接转为数值     True——1   False——0
    3）使用bool()转换为布尔值
    	所有的0和空转换为布尔值，结果都是False
    	其他非0和非空转为布尔值为Ture
    注意：所有的数据类型转换，都是产生了一个新的值，没有改变原来的值

输入和输出：
    1.输入：将数据打印到标准输出设备上(屏幕)，使用print()函数
        1）每个print()函数都会自动换行
        2）多行语句要对齐
        3）如果想要打印空行，直接使用print()里面不写内容
        4）一个print()函数可以打印多个内容，多个内容用逗号隔开
    2.输入：从标准设备中读取数据，使用input()函数
        1)会一直等待用户输入
        2）以回车结束
        3）使用一个变量来接收输入的值
        4）所有输入的内容都会返回字符串
        5）input()函数里面可以加参数，用来提示

标识符：用于变量，函数，类，模块等名字
规则：
    1）只能有字母、数字、下划线组成，并且不能以数字开头
    2）下划线开头的都是有特殊意义的，所以尽量不要以下划线开头
    3）严格区分大小写
    4）不能和内置函数，关键字，库名重复
        print(dir(__builtins__)) —— 查看python有哪些内置函数
        关键字：None，false，
            import keyword —— 导入keyword标准库
            print(keyword.kwlist) —— 查看python里面的关键字
规范：
    1）见名知意
    2）驼峰命名法：
        1>.大驼峰：每一个单词的首字母都大写 如：MyName  (类名使用)；
        2>.小驼峰：第一个单词首字母小写，后面单词的首字母都大写。如：myName (变量遵守)
    3）下划线分割法：把所有的单词都用下划线来分隔。 如：my_name
    变量：等号左边的是变量，可以保存任何内容
    对象：等号右边的是对象，拥有一个实际的值

字符串格式化方式：
    1）使用%格式化
        使用一段字符串作为模板，模板中有格式符，格式符的作用是为真实值预留位置
        语法：模板%值
        格式占位符：
            %s —— 对字符串占位
                %6s —— 指定宽度6
            %f —— 对浮点占位
                保留小数点后两位 %.2f
                %6.2f —— 浮点数指定整体宽度为6，并保留小数点后2位
                %06.2f —— 浮点数指定整体宽度为6，并保留小数点后2位，不足的位数用0不齐
            %d —— 对整数占位
                %6d —— 指定宽度位6
                %06d —— 指定宽度位6，不足以0补齐
        注意：传入真实值的时候，要按照预留的顺序输入
    2)使用f来进行格式化
        语法：f'字符串模板{}'  # 关键点
            f'字符串模板{age:>6}' —— 指定宽度为6，右对齐
            f'字符串模板{小数:.2f}' —— 保留2位小数
            f'字符串模板{小数:06.2f}' —— 保留两位小数，指定宽度6，0补齐
    3）字符串里面的特殊字符
        \n —— 换行符
        \t —— 制表符 tab键
        \\n —— \n 前面再加 \ ，代表转义符，会把有特殊意义的字符转成没有特殊意义的  —— r'字符串\n'
        print('我说，\'你好\'') —— 输出”我说，你好“

运算符：
    1）算数运算符
        % —— 取余     // —— 取整除后的商    ** —— 幂运算符
    2）比较运算符   返回的结果是布尔值，成立为Ture，不成立为False
        == —— 两个等号是比较，一个等号是赋值
    3）赋值运算符
        =   +=
    4）逻辑运算符
        and 与   or 或    not 非
        优先级：not > and > or
    5）成员运算符     返回结果是布尔值   判断字符串
        in 判断包含返回Ture，不包含返回False
        not in 不包含返回Ture，包含返回False
            print(a in b) —— b是否 包含a

        用列表来判断数字包含关系;
            f = 1; g = [1, 2, 3]
            print(f in g)
    6）身份运算符     返回结果是布尔值    对象
        is 判断是否指向同一对象
        is not
        id()函数可以打印出对象在内存空间的地址

    优先级：幂运算符 > 算数运算符 > 比较运算符 > 赋值运算符 > 身份运算符 > 成员运算符 > 逻辑运算符

程序设计三种基本结构：
    1.顺序结构：程序从上往下依次执行
    2.选择结构：根据条件成立与否来决定执行的代码块
    3.循环结构： 

选择结构：
    语法：
        if 条件:(True)
            执行里面的代码
        else:
            执行里面的代码
	语法2：
		if 条件:
			执行里面的代码
		elif 条件:
			执行里面的代码
		else
			执行里面的代码
	if...if ——每一个if判断都会执行
	
			b = ' '
			if b:
				print('b为真')
			--会打印b为真
循环
1.while循环：当条件成立时，一直执行某段代码，直到该条件不成立
	语法：		初始值
			  while 条件:
			  	循环体
			  	初始值变化
			  
2.for循环
	语法：for i in range(1,11)
		for...in...  i是变量用来接收range()函数里面的值
		range()代表整数序列-前闭后开
		每次循环自动去range()里面从左到右依次取值，赋给变量i
		range是整数序列，不能用于字符串

for循环更改适用于固定循环次数，或者遍历一个序列
while循环更使用于一些逻辑条件判断
如果for循环能够实现，就不用while循环

	打印5行5列*
	for i in range(1,6):
		for j in range(1,6):
			if i == 5:
				print('*', end = '\n')
			print('*', end = '\t')
		
for ... eles ... —— 如果for都执行完了，就会执行else，但是如果for循环里面有一次执行到break，就跳出循环

len(password) in range(6, 11): # 判断password的长度在6-10

数据结构：用来存储一组相关数据的容器
python的数据结构：
	1.列表	2.元组	3.字典	4.集合

列表(list):
	1.列表使用一对[]定义，里面可以存储任意类型的数据，多个值用逗号隔开；
	2.列表是有序的数据结构，可以通过索引取值，索引从左到右，从0开始
	3.列表是可变的
列表常用函数：
	1.len() —— 返回列表的长度
	2.append() —— 往列表的末尾追加一个值
	3.insert() —— 往列表指定的索引位置插入一个值
	4.remove() —— 删除列表中第一次出现指定的值
	5.pop() —— 默认删除最后一个，也可以指定索引进行删除
	6.sort() —— 升序排序；如果想要降序-sort(reverse=True)
	7.index() —— 返回指定值的索引
	8.count() —— 返回指定值出现的次数

元组(tuple):
	1.元组使用一对()定义，可以保存任意类型的数据
	2.元组是有序的数据结构
	3.元组是不可变
	4.如果要定义只有一个值的元组，需要在这个值后面加逗号 如；c = (3,)
		因为元组不可变的特点，通常使用元组来定义常量，如：数据库地址，账号密码等

字典(dict):
	1.字典使用一对{}定义，里面的数据使用键值对来保存，键值对用冒号分隔，冒号左边是键，右边是值
	2.一个字典里面，键是不能重复的，但是值是可以重复的
	3.键一般是字符串或数值，值可以是任意类型
	4.字典是无序的数据结构
	5.字典是可变的
字典的有点：
	1.数据对应关系清晰，因为里面的数据都是键值对
	2.查找方便，不需要通过循环，可以直接用键来取值
	3.因为字典无序，所以可以随意增加，不会影响之前的代码
字典的常用方法：
	1.增加和修改都是通过键=值，如：dict1['gae'] = 20；如果键存在，则为修改，如果键不存在，则为添加
	2.pop() —— 删除指定键值对
	3.查询：keys() —— 遍历键；直接遍历 for i in dict: —— 默认取键
			values() —— 遍历值
			items() —— 遍历键和值，需要用两个变量来接收
			get() —— 通过键来查询，如果查询不存在的键会返回None

集合(set)：
	1.集合使用一对{}定义，但是集合不是键值对
	2.集合不可重复，会自动去重
	3.集合是无序的数据结构
	4.集合是可变的，但只能增加和删除，不能修改

	b = {} —— 空字典		c = set() —— 空集合
	#列表去重#
	a = [1, 2, 3, 5, 2, 6, 3]
	print(list(set(a)))

			
字符串 —— str
	1.字符串使用引号定义的
	2.字符串是有序的
	3.字符串不可变的，所有对字符串的修改，都不是改变字符串原来的值，而是产生一个新的值
字符串和列表之间的转换
	str.split()：默认按照空白字符进行切割，转换成一个列表
	str.split('\n')：以换行符切割，
	str.split('m'):以m切割，如果m在开头或者结尾，都会产生一个空格符
		如果以不在字符串中的元素来切割，就会把整个字符串打印在列表中
	
	print(' '.join(list1))：使用空格把列表拼接成字符串
	
	str.strip()：去掉字符串前后的空白字符(空格，\n,\t)
		lstrip()：去掉走边的		rstrip()：去掉右边的
	str.strip('*#')：去掉指定字符，*#是没有顺序的，是两个字符
	
	str.count('zhou')：统计‘zhou’在字符串中出现的次数，默认从索引0开始，统计到结束位置，索引的位置前闭后开
	str.fand('zhou')：找到第一次出现'zhou'的索引，先满足'zhou'，在返回第一个字符出现的索引，可以添加开始和结束的索引
	str.index()：与fand方法一样
		index没有找到会报错，fand没有找打输出-1
	str.startswith('my'):判断字符串是否以'my'开头，返回Ture/Fals
		str.startswith('my', 12):从索引12 的位置判断，是否是12开始
		str.endswith('zhou'):判断是否以'zhou'结尾
	str.replace('zhou', 'zhang'):将所有'zhou'替换成'zhang'
		str.replace('zhou', 'zhang', 1):替换一次
	str.isdigit():如果str字符串是纯数字，返回Ture/False
	str.isalpha():如果str字符串是纯字母，返回Ture/False；汉字也会被判断为字母
	str.encode()/str.decode():编码和解码
	
	
序列：有序的都是序列，列表，元组，字符串
	序列两个主要特征：
		1.索引操作符：可以通过索引从序列中抓取一个特定值
			索引从左往右，从0开始，从右往左，从-1开始
		2.切片操作符：可以通过索引从序列中抓取一部分值
			切片操作符也是用一对[]，括号有一对数字，并用冒号隔开；第一个数字代表切片开始的位置，第二个数字代表切片结束的位置，并且是前闭后开
			print(c[:])：默认切出所有 print(c[::])；c为字符串
			print(c[::2]):以步长为2来取，默认步长是1
			print(c[::-1]):表示倒着取值
		
		判断用户输入的是否为回文数
			number = input('输入数字')
			if number == number(::-1):
				print(f'{number}是一个回文数')


列表生成式/列表推导式
	生成式：new = [i*0.9 for i in before]
	适用场景：从源列表一次取值，做同样的处理，在添加到新的列表中
	
函数：是一段可重用的程序语句，实现某一个具体的功能
	def 函数名()：
		函数体
	函数名() # 调用函数
	def只是定义函数，不是调用
	
	def drinks(no): # 如果在定义函数的时候，有未知数参与，形式参数用来占位；多个形参用逗号隔开
	
函数里面的参数：
	1.形参:在定义函数的时候，如果有未知数据的参与，就可以在函数后面的括号里设置形参
	2.实参:如果定义函数的时候，设置了形参，在调用函数的时候就必须要传入对应的实参
	3.默认参数：给形参赋默认值，就叫默认参数/缺省参数 def info(xx, xx, ss = 'asd')；
		如果传入实参，就以实参为准；
		如果形参设置了默认参数，后面的形参都要设置默认值
	4.关键字参数：在传递实参的时候，指定形参的名字  info(tag = '这碗大')
		关注键字可以颠倒形参的顺序
	了解：不定长参数： def f1(*args): # *args 不定长参数
			args是元组
			
变量：
	1.全局变量：定义在函数外边，作用于去全局(函数内部和外部都可以使用)
	2.局部变量：定义在函数里面，只作用于函数内部
		局部变量的优先级高于全局变量，当局部和全局变量重名，以局部为准；
		global关键字可以提升局部变量的作用域，可以把局部变量升级为全局变量；
		
函数的return
	1.跳出函数，只要执行到return，函数后面的代码就不会被执行
	2.给函数设置一个返回值，所有的函数都默认返回None；返回值可以供后续使用
		return 'basketball'
	函数中使用return，调用函数，是看不到返回值地方；返回值必须打印才能看到；多个返回值可以使用多个变量来接收
	
定义函数三部曲：
	1.确认函数的名字(见名知意)
	2.确认函数有没有形参(考虑函数是否有未知数据的参与，有，就设置成形参)
	3.确定函数有没有返回值(a.如果后续的程序要使用当前函数里面的数据b.需求里明确说明要返回值)
	
递归函数：一个函数在内部调用了自己
	递归的死循环，每次调用函数所占用的内存不会释放，所以递归到一定的深度就会报错 
核心思想：每一次递归，整体问题都要比原来减少，并且递归到一定深度时，要给出结果结束递归
	
	
文件操作(文本文件)
	1.打开文件
		使用open()函数，后面要传入两个参数，一个参数时文件的路径，第二个参数时文件的打开方式，第三个参数为选传，如果被打开的文件的字符集是utf8，就需要加第三个参数encoding='utf8'，默认gbk打开
			路径：	绝对路径：从盘符开始，一层一层的路径
				  相对路径：相对于当前文件，目标文件的路径
		打开方式：
			r：只读 打开不存在的文件，会报错
			w：只写(覆盖写入，打开文件后，会先把文件清空)；打开不存在的文件，会新建
			a：只写(追加) append
		文件可读可写方式：
			r+ ：可读可写，打开文件后，指针在文件开头；打开不存在的文件，会报错
				写入后指针在文件末尾，使用file.seek(0)将指针调到开头；
				如果打开文件后直接写入，会覆盖掉原来内容；
			w+ ：打开文件后，会先清空文件；打开不存在的文件，会新建
			a+ ：打开文件后，指针会在文件的末尾；打开不存在的文件，会新建
	2.读取/操作文件
		读取的方法：
			read：读取所有，返回字符串
				s.read(3)：指定对三个字符
			s.readline()：读取一行
			s.readlines()：读取所有，返回列表，文件中的一行为列表中的一个值
			s.seek(0)：如果读取完所有内容后，指针会移动到末尾，使用seek方法把指针移动到0
		写入的方法：
        	s.write('字符串') 只能写入字符串
        	s.writelines(['123', '234']) 可写入集合，集合中的元素必须是字符串,也可写入字符串
        	
	3.关闭文件
		close()
	
    with open 语法：可以自动关闭文件
		with open('路径', '打开方式', encoding='') as file:  # 打开文件命名为file
			all = file.read()
		print(file.closed)  # closed验证文件是否关闭，返回True
		
	复制图片：
		with open('图片路径', 'rb') as file:	# rb 用来读取二进制文件(图片，视频，音频...)
			all = flie.read()
		with open('新路径', 'wb') as file:	# wb 用来写入二进制文件
			file.write(all)
			

模块和包
	包：一个python文件夹
	模块：一个python文件
	
	导入模块：
	import random	#导入整个random模块，就可以使用random里面的所有函数
	random.randint(1, 4)	#使用'模块名.函数'来使用
	
	from random import randint as r		#从random模块里面，只导入了randint函数; as用来取别名
	print(randint(1, 4))
	
	导入自定义模块：
		如果别导入的模块和当前文件在同一路径下，可以直接import导入；
			注意：如果别导入的模块里面有调用函数或者打印语句，导入后会自动执行代码
		如果被导入模块不在同一路径下，就需要从项目名的下一层开始导入
		如果在根目录下，直接导入
		

异常处理
	
	try:	#尝试执行里面的代码
		number = int(input('输入数字：'))
		print(100/number)
	except Exception as e:	#如果try里面的代码报错会直接执行except里面的代码，然后程序继续
							#如果try里面的代码没有报错，就会跳过except
							#Exception 代表所有异常的父类，包含了所有的错误类型
							#as e 代表把这个错误对象赋值给变量e
		print('try里面代码报错')
		print(e)
	else:	#如果try里面的代码没有报错，就会执行else里面的代码，出错就跳过else
		print('没错')
	finally:	#不管try不管有没有报错，都会执行finally里面的代码
				#通常在函数里面except和else里面都写了return的时候使用
		print('执行')
	print('后续代码')
	

程序调试：debug
	1.在需要调试和行数打一个断点，右键点击调试，程序会停在断点的行数(还未执行的一行)
	2.点击'步过'(F8)按键，程序会执行当前代码
	

python连接数据库
	如果第一次连接数据库，需要先下载第三方数据库 pymysql
	下载方式：1）打开cmd 输入命令 pip install pymysql 进行下载
			2）使用pycharm下载：文件-设置-python解释器-点击+号-输入pymysql-点击安装
	1.先导入pymysql
		import pymysql
	2.建立连接对象	#connect用来建立连接对象
		db = pymysql.connect(
			host='localhost',	#要连接的数据库的ip
			port=3306,	#数据库的端口号，必须以int类型传入
			user='root',
			password='123456'	#以str传入
			db=''	#要连接的数据库名
			charset='utf8'	#字符集
		)
	3.创建游标对象:使用连接对象调用cursor方法来创建游标对象，后续对数据库的操作都使用游标对象来实现
		link = db.cursor()
	4.操作数据库:execute()函数用来执行sql语句
		link.execute('sql语句')	#只执行查询语句，查询结果现在还保存在游标对象里
		all = link.fetchall()	#把游标对象里面保存的内容读取出来；游标会停在尾部
									link.scroll(0, 'absolute') 把游标移动到最前面
			link.fetchone() —— 读取一行 返回元组
			link.fetchmany(1) —— 读取指定行数的数据 返回元组嵌套全组
		print(all)
		
		link.execute('sql插入数据语句')
		db.commit()	#如果对数据库是增删改操作，就必须
	
		数据库参数化：
			id = 4
			name = 'xioaming'
			sex = 'man'
			link.execute('insert into emp values(%s, %s, %s),(id, name, sex)')
			link.execute(f'insert into emp values({id}, "{name}", "{sex}")')
			link.executemany('insert into emp values(%s, %s, %s),[(6, 'xiaob', 'man')]')
				可以插入多条数据
			
		将一张表的内容复制到另一张表
			link.execute('select * from info')
			all = link.fetchall()
			link.executemany('insert into info values(%s, %s, %s)', all)
	5.关闭游标对象
		link.close()
	6.关闭连接对象
		db.close()
	
	
面向过程：是一种以事件为中心的编程思想，重点关注功能实现的步骤	
	优点：相对来说条例更清晰，更易读；
	缺点：重复代码多，函数量大，不利于后期维护
面向对象：是一种以对象为中心的编程思想，重点关注结果；面向对象的核心思想就是封装，把相关的功能和属性封装到一个类里面
	1.类：对同一类事物的总体描述
		代码：
			属性(静态特征):
				1）类属性(静态属性)：直接定义在类里面，这个类的所有对象都拥有一样的值
					在类外边类属性可以被类和对象调用
				2）实例属性：定义在构造方法里面，不同的对象所拥有的值不一样
					只能被对象调用
			方法(动态功能)
				1）构造方法(初始化方法/init方法)：
					调用时机：在实例化对象的时候，自动调用；通常用来给实例属性赋值
				2）实例方法：
					类里面的普通方法，都是实例方法；第一个参数是self，代表当前对象
					类不能直接调用实例方法，对象可以调用实例方法
					在其他方法里面，需要用self来调用实例方法
				3）类方法：通常一个类的所有对象都拥有的方法，就可以定义成类方法
					类方法前面必须加上@classmethod装饰器(在不改变代码的前提下，让代码实现更多功能)
                        @classmethod
                        def function(cls):	# 类方法的第一次参数必须是cls，代表当前类
                            print('这是一个类方法')
					对象和类都可调用类方法
					不能在类方法里面调用实例方法，反之可以
					调用类属性用cls.类属性
				4）静态方法：跟类无关的工具方法（优先级最低）什么方法都调用不了
					必须使用@staticmethod装饰器
						@staticmethod
						def jingtai():
							print('静态方法')
	2.对象：从类里面实例化出来的一个实实在在的对象
	
	面向对象的三大特性：
		1）封装：把相关的属性和方法都封装到类里面，目的是增加代码的复用性(以及安全性)
		2）继承：子类可以继承父类的属性和方法
				被继承的类叫父类/基类/超类
				继承后的类叫子类/导出类
					class Animal:	# 父类
					class Cat(Animal):	# 子类
				父类可以被多个子类继承
				可以继承多父类，如果有相同的属性或方法，以继承到的第一个父类为准
		3）多态：当子类和父类拥有相同的属性或方法时，子类会覆盖掉父类的方法/属性，总是调用自己的
	
	
正则表达式：是一种用来描述某种字符串规则的通用逻辑公式，使用预先定义好的正则表达式，来检索字符串中满足规则的文本
	re标准库：
		re.findall()：查找所有满足条件的文本，以列表的形式返回
		re.match()
		re.search()
		上面三个方法，里面必须传入两个参数，第一个参数是正则表达，第二个参数是要查找的字符串，第三个参数为选传，re.I-代表不区分大小写；re.S-匹配内容包含换行符
	
常用元字符：
	^ 匹配开头	re.findall(r'^sd', str1)判断字符串str1是否以sd开头，是返回sd列表，否返回[]
	$ 匹配结尾	re.findall(r'sd$', str1)判断字符串str1是否以sd结尾
	[] 选择匹配里面的单个字符	re.findall(r'[asd]', str1)匹配里面的单个字符，匹配a,b,c
	(|) 选择匹配里面的字符串	re.findall(r'(ad|as)', str1)匹配组合字符串，返回ad或as
	{} 控制前一个字符的数量	re.findall(r'ab{2}', str1)匹配abb
		{1,3}最多匹配3个，最少匹配1个，优先匹配最多的
	\d 匹配数字
		\d\d = \d{2}匹配两位数
		[0-9] 匹配0-9的数字
	\s 匹配空白字符
	\w 匹配字母，数字，下划线(包括汉字)
		[a-z\d_] 匹配字母数字下划线
	. 匹配除\n以外的任意字符
		re.findall(r'\.', str1) 匹配普通字符.		匹配一些特殊字符用\转义
		
	* 匹配前一个字符0-无限次 等同于{0,}
	+ 匹配前一个字符1-无限次 等同于{1,}
	? 匹配前一个字符0-1次 等同于{0,1}
	默认贪婪模式，会优先匹配更多条件

match():从字符串开头的位置进行匹配，如果匹配成功，返回的是match对象，匹配失败返回None
	result = re.match(r'python', str)
	result.group() —— group方法提取对象的结果内容
	result.span() —— span方法提取索引
	
search():从字符串第一次出现对应内容的位置进行匹配，如果匹配成功，返回的是search对象，匹配失败返回None
	result.group() —— group方法提取对象的结果内容
	result.span() —— span方法提取索引