python学习笔记（一）pip下载

S1 is S2 #is判断的是s1和s2的地址id

Join()方法是多个字符串拼接

数据结构	是否可变	是否重复	是否有序	定义符号
列表（list）	可变	可重复	有序	[]
元组（tuple）	不可变	可重复	有序	（）
字典（dict）	可变	Key不可重复	无序	{key,value}
		Value可重复
集合（set）	可变	不可重复	无序	{}

向列表中添加元素

1、#向列表的末尾添加一个元素

lst.append(100)

lst2=['hello','world']

2、#lst.append(lst2) #将lst2作为一个元素添加到元素末尾

lst.extend(lst2) #向列表的末尾一次性添加多个元素

1. #在任意位置上添加一个元素
   lst.insert(1,90) #在索引为1的位置上添加一个90的元素

2. 0#将索引为1的后面的元素切掉，然后替换上lst3的元素

lst3=[True,False,'hello']

lst[1:]=lst3

向列表中移除元素

1、#从列表中移除一个元素，如果有重复元素只移除第一个元素

lst=[10,20,30,40,50,60,30]

lst.remove(30)

2、#pop()根据索引移除元素

lst.pop(1) #将索引为1的元素移除

lst.pop() #如果不指定参数，将默认删除列表的最后一个元素

3、'''不产生新的对象，而是删除原列表中的内容'''

lst[1:3]=[] #将一到三位置的元素切走，用空列表代替

4、'''清除列表中的所有元素'''

lst.clear()

5、'''del语句将列表对象删除'''

del lst

向列表中添加元素

3. #一次修改一个值,根据索引修改数值
   lst[2]=100

4. #切片的形式将列表中的值替换
   lst[1:3]=[300,400,500,600]

对列表进行排序

不写默认为升序排序

1、#resver=True 表示降序排序，reverse=False 表示降序排序，在原来列表的基础上进行排序

lst.sort(reverse=True) lst.sort(reverse= False)

2、使用内置函数sorted()对列表进行排序，将产生一个新的列表对象

new_list=sorted(lst)

desc_lst=sorted(lst,reverse=True)

列表生成式

#将一到九的i值,存到列表中

lst=[i for i in range(1,10)]

字典

'''key的判断'''

score={'张三':100,'李四':200,'王五':32} #建立一个字典

'''第二种创建方式'''

student=dict(name='jack',age=20)

print('张三' in score)

print('张三' not in score)

del score['张三'] #删除键

print(score)

#score.clear() #清空字典中的数值

print(score)

score['陈六']=98 #添加元素

print(score)

score['陈六'] =100 #修改陈六的值

#获取所有的key

keys=score.keys()

#获取所有的value

values=score.values()

#获取所有的键值对

items=score.items()

'''字典生成式'''

#创建两个列表

items=['Fruits','Books','Others']

prices=[96,75,83]

d={item:price for item,price in zip(items,prices)}

print(d)

#upper()方法，将打印出来的值全部转化成大写

d={item.upper():price for item,price in zip(items,prices)}

print(d)

#如果两个列表元素长度不相等，会以元素少的列表为标准

元组

'''可变序列 列表，字典'''

'''不可变序列 字符串，元组'''

'''元组的创建方式'''

t=('python','world',98)

t2='python','world',98 #省略了一个小括号

t3=('python',) #只有一个数据的时候，如果不加逗号就认为是str类型

'''第二种创建方式'''

t1=tuple(('python','world',98))

#空元组

t4=()

t5=tuple()

集合

'''集合的创建方式'''

'''第一种创建方式，使用{}'''

s={1,2,3,4,5,5,7,7} #集合中的元素不允许重复

'''第二种创建方式，使用set()'''

s1=set(range(6))

s2=set([1,2,33,44]) #将列表转化成集合

'''集合元素的新增操作'''

s.add(80) #一次添加一个元素

s.update({200,400,300}) #一次至少添加一个元素

'''集合的删除操作'''

s.discard(100) #如果集合中没有该元素，该方法不会抛异常

s.remove(200) #如果集合中没有该元素，该方法抛异常

s.pop() #随机删除一个数，pop没有参数

s.clear() #清空集合中的元素

#两个集合是否相等，元素相同就相等

#在集合中与顺序无关

print(s==s2)

print(s!=s2)

'''一个集合是否是另一个集合的子集,方法issubset'''

print(s2.issubset(s1))

'''一个集合是否是另一个集合的超集,方法issuperset()'''

print(s1.issuperset(s2))

'''两个集合是否含有交集，方法isdisjoint()'''

print(s2.isdisjoint(s3)) #有交集为false

print(s2.isdisjoint(s4)) #没有交集为true

#集合的数学操作

#（1）交集

s1={10,20,30,40}

s2={20,30,40,50,60}

print(s1.intersection(s2))

print(s1 & s2) #intersection()与&等价

#（2）并集

print(s1.union(s2))

print(s1 | s2) #union()与|等价

#（3）差集操作

print(s1.difference(s2)) #s1-(s1∩s2)

print(s1-s2) #different与-等价

#（4）对称差集

print(s1.symmetric_difference(s2)) #(s1-(s1∩s2))∪（s2-(s1∩s2)）

print(s1^s2)

'''字符串的查询操作'''

s='hello,hello'

print(s.index('lo')) #查询字符串第一次出现的位置，如果查不多报错

print(s.find('lo')) #查询字符串第一次出现的位置，如果查不到返回-1

print(s.rindex('lo')) #查询字符串最后一次出现的位置，如果查不多报错

print(s.rfind('lo')) #查询字符串最后一次出现的位置，如果查不多返回-1

'''字符串中的大小写转换的方法 '''

s=’python,hellp’

a=s.upper() #将所有的字母全都转换成大写,转换之后会成为一个新的字符串对象

b=s.lower() #将所有的字母转换成小写

s2.swapcase()#小写变大写，大写变小写

print(s2.title()) #每个英文单词的第一次字母变成大写，其余字母变成小写

#字符串填充

s='hello,Python'

#居中对齐

print(s.center(20,'*'))#宽度设置为20，填充符设置为*，左右均等填充*

#左对齐

print(s.ljust(20,'*'))#向右填充，可以默认为空

print(s.ljust(10))#宽度比字符串短，会显示字符串

print(s.ljust(20))#空格填充

#右对齐

print(s.rjust(20,'*'))#向左填充，可以默认为空

#右对齐，使用0填充

print(s.zfill(20))

#添加到减号之后

print('-8910'.zfill(8))

劈分符

s1='hello|world|Python'

'''replit()从左侧开始劈分'''

lst=s.split(45)#默认分隔符为空格

print(s1.split(sep='|'))#sep= 指定分隔符

print(s1.split(sep='|',maxsplit=1))#maxspilt= 设置最大的劈分次数

'''replit()从右侧开始劈分'''

print(s.rsplit()) #默认分割符为空格

print(s.rsplit('|'))

print(s.rsplit('|',maxsplit=1))

'''字符串的判断'''

s='hello,python'

# 判断是否是合法的标识符字符串 数字、字母、下划线

print('1.',s.isidentifier())False

print('2.','hello'.isidentifier())

print('3.','张三'.isidentifier())

print('4.','张三_123'.isidentifier())

#判断指定的字符是否全部是由空白字符组成

print('5.','\t'.isspace())

#判断指定的字符是否全部由字母组成

print('6.','abc'.isalpha())

print('7.','张三'.isalpha())

print('8.','张三1'.isalpha())

#判断指定字符是否全部由十进制数字组成

print('9.','123'.isdecimal())

print('10.','123四'.isdecimal())

print('11.','ⅠⅡⅢ'.isdecimal())

#判断指定的字符全部由数字组成

print('12.','123'.isnumeric())

print('13.','123四'.isnumeric())

print('14.','ⅠⅡⅢ'.isnumeric())

#是否全部由字母和数字组成

print('15.','abc1'.isalnum())

print('16.','张三123'.isalnum())#true

print('17.','abc!'.isalnum())#false

'''字符串的替换'''

#用java替换了字符串中的python

print(s.replace('python','java'))

#第三个参数为指定替换的次数

s1='hello,Python,Python,Python'

print(s1.replace('Python','java',2))

#join连接列表中的字符串

lst=['hello','java','python']

print('|'.join(lst))#元素的之间的连接符为|

print(''.join(lst))#元素之间没有连接符，形成一个新的字符串

字符串比较

print('apple'>'banana') #false #比较的是字符的原始值

print(ord('a'),ord('b')) #ord获取原始值

print(chr(97),chr(98)) #chr通过原始值获取字符

#==与is的区别 ==比较的是值（value） is比较的是内存地址（id）

print(s[1:5:1]) #切片，从1开始到5结束，步长为1

s2=s[6:] #由于没有指定终末位置，切到最后

s1=s[:5] #由于没有指定起始位置，从0开始切

print(s[::-1]) #步长为负数，倒着切，从字符串的最后一个到第一个

'''格式化字符串'''

#（1）%占位符

name='张三'

age=20

print('我叫%s,今年%d岁' % (name,age))

#效果：我叫张三,今年20岁

#（2）{}

print('我叫{0}，今年{1}岁'.format(name,age))

#效果：我叫张三,今年20岁

#(3)f-string

print(f'我叫{name},今年{age}岁')

#效果：我叫张三,今年20岁

print('%10.3f' % 3.1415926) #一共站了10个位，小数点保留3位

print('{:10.3f}'.format(3.1415926)) #一共占了十位，其中三位小数

print('{0:.3}'.format(3.1415926)) #.3表示一共三位数字，0（可以省略）

字符串的编码和解码

s='天涯共此时'

#编码

print(s.encode(encoding='GBK')) #在GBK这种编码格式中，一个中文占两个字节

print(s.encode(encoding='utf-8')) #在utf-8这种编码格式中，一个中文占三个字节

#解码

#byte代表一个二进制数据（字节类型的数据）

byte=s.encode(encoding='GBK')

print(byte.decode(encoding='GBK')) #GBK编码，用GBK解码

byte=s.encode(encoding='utf-8')

print(byte.decode(encoding='utf-8'))

函数

def 函数名(参数)：

函数体

Return 值

按照顺序进行参数传递，按照关键字进行赋值

函数的返回值

函数写不写返回视情况而定

'''1、如果函数没有返回值，函数执行完毕之后不需要给调用处提供数据，return可以省略不写

2、函数的返回值，如果是1个。直接返回类型

3、函数的返回值，如果是多个，返回的结果为元组'''

当不知道参数传入多少个，用*代替例如：

def fun(*args): #函数定义时的可变的位置参数，只能有一个

print(args)

fun(10)

fun(10,30)

def fun1(**args): #字数可变的关键字形参，只能有一个

print(args)

fun1(a=10)

fun1(a=20,b=30,c=40)

def fun2(*arg1,**arg2):

pass

#在一个函数定义过程中，既有个数可变的关键字形参，又有个数可变的位置形参，位置形参要在关键字形参之前

global age #如果局部变量用global声明，那么局部变量就变成了全局变量

'''递归函数，函数套函数'''

def fac(n):

if n==1:

return 1

else:

res=n*fac(n-1)

return res

print(fac(6))

#结果：720

#斐波那契函数

def fib(n):

if n==1:

return 1

elif n==2:

return 1

else:

return fib(n-1)+fib(n-2)

#斐波那契数列第6位上的数字

print(fib(6))

#输出这个数列的斐波那契数字

for i in range(1,7):

print(fib(i),end='\t')

Bug的常见类型

5. 漏了末尾的冒号，如if语句，循环语句，else子句等

6. 缩进错误，该缩进的没有缩进，不该缩进的瞎缩进

7. 把英文字符写成中文字符，比如：引号，冒号，括号

8. 字符串拼接的时候，把字符串和数字拼在一起

9. 没有定义变量，比如说while的循环条件的变量

10. ‘==’比较运算符进和‘=’赋值运算符的混用

#try...expect...else...

try:

a=int(input("请输入第一个整数："))

b=int(input("请输入第二个整数："))

result = a / b

except BaseException as e: #捕获错误e,如果出错就把错误的类型e输出

print('输出错误：',e)

else:

print('输出结果为：',result) #如果没有出错，就输出结果。

#结构：try...expect...else...finially...

try: #感觉一下程序可能报错，就放到try程序体中

a=int(input("请输入第一个整数："))

b=int(input("请输入第二个整数："))

result = a / b

except BaseException as e: #捕获错误e,如果出错就把错误的类型e输出

print('输入错误',e)

else: #如果没有出错，就输出结果。

print('输出结果为：',result)

finally: #无论程序出错，都会执行该条命令

print('谢谢您的使用')

程序产生的异常类型：

#(1)数学运算异常

print(10/0) #ZeroDivisionError

#(2)索引异常

lst=[11,22,33]

#print(lst[4]) #IndexError

#（3）映射中没有这个键

dic={'name':'张三','age':'20'}

print(dic['gender']) #KeyError

#(4)未声明/初始化对象（没有属性）

print(name) #NameError

#(5)语法错误,这种写法不承认，在python中变量没有类型

int a=20 #SyntaxError

#(6)传入无效的参数，值与类型不相符

a=int('hello') #ValueError

#使用traceback模块打印异常信息

import traceback

try:

print('------------')

print(1/0)

except:

traceback.print_exc()

#作用：我们可能会将异常信息存到文件中，这个文件叫log日志

面向过程

面向对象-->类与对象

类：是多个类似事物组成的群体的统称。能够帮助我们快速理解和判断事物的性质

数据类型：不同的数据类型属于不同的类

使用内置函数查看数据类型

对象：100,99,520都是int类之下包含的相似的不同个例。这个个例专业属于成为实例或对象

Python中一切皆对象，例如列表对象、字典对象...

类的框架：

Class 类名：

Pass

例如：

class Student: #student为类的名称（类名）由一个或者多个单词组成，每个单词的首字母大写，其余字母小写

pass

'''类的组成：类属性、实例方法、静态方法、类方法'''

这是一个学生类别的模板

class Student: #student为类的名称（类名）由一个或者多个单词组成，每个单词的首字母大写，其余字母小写

native_pace='吉林' #直接写在类里的变量，成为类属性

# 初始化方法

def __init__(self,name,age):

self.name=name #self.name实例属性，进行了一个赋值操作，将局部变量的name的值赋给实体属性

self.age=age

#实例方法

def eat(self): #在类中定义的实例方法，在类之外定义的叫做函数，在类里定义的叫做方法

print('学生在吃饭...')

#静态方法

@staticmethod

def method(): #用staticmethod定义，括号里不准用self

print('我使用staticmethod进行修饰，所以我是静态方法')

#类方法

@classmethod

def cm(cls): #s使用classmethod修饰，就要传一个cls

print('我是类方法，因为我用了classmethod进行休息')

对象的创建

对象的创建又称为类的实例化

语法：实例名=类型（）

类属性：类中方法外的变量成为类属性，被该类的所有对象所共享

类方法：使用@classmethod修饰的方法，使用类名直接访问的方法

静态方法：使用@staticmethod修饰的主法，使用类名直接访问的方法

使用案列看chap12/demo5

一个Student类可以创建多个Student类的实例对象，每个实体对象的属性值不同

总结：

点击这个选项才能导入自己自定义的模块

以主程序运行：

if __name__ == '__main__':

print(add(10,20)) #只有当点击运行本模块时才会执行运算

Import 报名.模块名 as 别名

#encoding=GBK #更改存储方式，默认为utf-8

print('你好，中国。')

file=open('a.txt','r') #读取文件

print(file.readlines())

file.close()

#写入文件，如果文件不存在就创建文件，如果存在就覆盖原本的内容

file=open('a.txt','w')

print(file.readlines())

file.close()

#写入文件，如果把命令符改称为a,会在原有的内容后面进行追加内容

file=open('b.txt','a')

file.write("Python")

file.close()

scr_file=open('jmqs.png','rb') #以二进制的形式阅读改文件

target_file=open('copyjmqs.png','wb')#以二进制的形式书写改文件

target_file.write(scr_file.read())#在阅读scr.file文件的时对target_file文件进行编写

target_file.close()

scr_file.close()

第三方模块的安装Pylnstaller

将文件执行打包操作

（-F的意思是只形成一个扩展名为.exe的可执行文件）

Pylnstaller -F 路径

11. id代表唯一标识符，名字不重复

12. 起一个人读的名字

13. 模型的id(标识符，即给哪个模型权限)

14. 群组的名字（给哪个用户组赋予这个权限）

访问权限是针对用户访问模型的，记录规则是针对用户能否访问其他用户信息的。

包的下载方式

1、在pip install XXX--default-timeout=100 -i https://pypi.tuna.tsinghua.edu.cn/simple即可。

有时候只需更换国内安装源便可解决问题。

15. pip install requests==2.21.0 -i http://pypi.douban.com/simple/ --trusted-host pypi.douban.com

通过pip卸载包：Pip uninstall 包名

如果产生报错那就用：python -m pip uninstall 包名

如果上述安装包命令报错，那么就需要在前面加上python -m

任何使用pip或pip中的包的命令行前面都要加python -m

如果要想通过requirements.txt文件下载，如下：

pip install -r requirements.txt ...