【python基础】

python安装

idle：python自带的简单的开发环境

输出函数print()

一、print会输出

1. 数字
2. 字符串（必须加引号）
3. 含有运算符的表达式（例如 3+1 其中3，1是操作数，+是运算符）（进行运算）

#输出数字
print (98.5)

#输出字符串
print ("Hello, clovershrub")
print('hello,world')

#输出表达式
print(3+1)

二、print()函数还可以将内容输出的目的地

1. 显示器
2. 文件：

fp=open(‘D:/text.txt’,”a+”)#文件不存在就创建，存在就在文件内容后面继续追加
print(‘helloworld‘,file=fp)
fp.close()

注意：所指定的盘符存在，使用file=fp
三、print()函数的输出形式

1. 换行
2. 不换行：使用,分割，print(‘hello’,’world‘,’Python‘)

转义字符和原字符

+转义功能的首字母

换行：\n（newline）

回车：\r (return)

如print(‘hello\rworld’)         在hello的下一行输出world

水平制表符：\t (tab)

如print(‘hello\tworld’)     输出 hello  world

而print(helloooo\tworld)  输出helloooo  world

因为hell这四个字母成为一个字表位，o后\t 占用了其余三个

若是无剩余 则会新开一个字表位

退格：\b (backspace)

如print(‘hello\bworld’)          退格输出hellworld

*原字符：不希望字符串中转义字符起作用，就会使用原字符，即在字符串上加上R或者r
如print(r‘hello\nworld’)         输出hello\nworld

二进制与字符编码

8bit（位） — 1 byte （字节）——256种状态——256种符号
1024byte——1KB
1024KB——1MB
1024MB——1GB
1024GB——1TB

标识符和保留字

一、保留字：被赋予了特殊意义，无法在对象起名中使用

1. 新建 keyword.demo
2. import（导入） keyword
3. print(keyword.kwist) 输出关键字列表
   
   二、变量/函数/类/模块和其他对象 所起的名字叫做标识符
   三、规则：
4. 字母、数字、下划线
5. 不能以数字开头
6. 不能是保留字
7. 须严格区分大小写

变量的定义和使用

数据类型

整数类型—int ——98，可以表示正数、负数、0
浮点数类型——float ——3.1415926
布尔类型——bool——True 、False
字符串类型——str——“人生苦短，我用Python”（加上引号就是，不管是单引号、双引号、三引号、都是字符串）

整数类型

一、整数不同进制的表示方式

1. 十进制——默认
2. 二进制——以0b开头
3. 八进制——以0o开头
4. 十六进制——以0x开头

浮点类型

布尔类型

字符串

类型转换

str()

与其他语言不同的是，字符串和其他数据类型通过“+”连接时，其他数据类型不会自动转换为字符串，而是报错，解决办法就是进行类型转换

a=10

b=198.8

c=False

print（type（a），type（b），type（c））
# 输出：<class ‘int’><class ‘float’> <class ‘bool’>

print（str(a),str(b),str(c),type（a），type（b），type（c））
# 输出：10 198.8 False <class ‘str’> <class ‘str’> <class ‘str’> 

int()

将str转为int类型，str必须是整数串，否则会报错，float转int会截取float的整数部分

s1='128'
f1=98.7
s2="45.6"
ff=True
s3="hello"
print(type(s1),type(f1),type(s2),type(ff),type(s3))
print(int(s1),type(int(s1))) #字符串为数字串
print(int(f1),type(int(f1))) #截取整数部分，小数舍掉
#print(int(s2),type(int(s2))) #字符串为小数串
print(int(ff),type(int(ff)))
#print(int(s3),type(int(s3))) #字符串必须为数字串且为整形

float()

1. 非数字串不允许转换
2. 布尔值true转1.0，false转0.0

s1='128.98'
s2="76"
ff=True
s3="hello" 
i=98
print(type(s1),type(s2),type(ff),type(s3),type(i))
print(float(s1),type(float(s1)))# 128.98
print(float(s2),type(float(s2)))# 76.0
print(float(ff),type(float(ff)))# 1.0
#print(float(s3),type(float(s3))) #非数字串不允许转换
print(float(i),type(float(i))) # 98.0

注释

含有三种类型的注释

1. 单行注释——以＃开头，直到换行结束
2. 多行注释——一对三引号代码 多行注释

'''多行注释
多行哦'''

3. 中文编码声明注释——在文件开头 以指定源码文件的编码格式

input函数的使用

input()接收的参数是程序对用户的提问，会将用户的输入赋值给present变量

#输入函数input
prasent=input('大圣想要什么礼物呢？')
print(prasent,type(prasent))# 输出：用户键盘输入的内容，类型为str

# 从键盘录入两个整数，计算两个整数的和
a=int(input('请输入一个加数：'))
b=int(input('请输入一个被加数：'))
print(type(a),type(b))
print(a+b)
#print(int(a)+int(b))

运算符

python中运算符：算术运算符、赋值运算符、比较运算符、布尔运算符、位运算符

算数运算符

标准算术运算符：+、-、*、/、整除//
取余运算符：%
幂运算符：**

print(1+1) #加
print(1-1) #减
print(2*4) #乘
print(11/2) #除
print(11//2) #整除运算
print(11%2) #取余
print(2**3) #幂运算 2的3次方

print(9//4)# 2
print(-9//-4)# 2
#一正一负进行整除时，向下取整
print(9//-4)# -3
print(-9//4)# -3

# 一正一负进行取余时，遵循公式：公式 余数=被除数-除数*商
print(9%-4)# 9-(-4)*(-3) 9-12-->-3
print(-9%4)# -9-4*(-3) -9+12-->3 

赋值运算符

a=3+4
print(a)# 7
b=c=d=20
# 以下3个输出都是同一个值
print(d,id(d))# 14645450672
print(b,id(b))# 14645450672
print(c,id(c))# 14645450672

a=20
a+=30
print(a)# 50
a*=2
print(a)# 100
a/=30
print(a)#3.33333333
a%=3
print(a)# 0.11111111

# 支持系列解包赋值，变量个数和值的个数一定要一致，否则会报错
a,b,c=1,2,3
print(a,b,c)# 1，2，3
# 系列解包赋值的用处：交换两个变量
a,b=10,20
print('交换前',a,b)# 10，20
a,b=b,a
print('交换后',a,b)# 20，10

比较运算符

比较运算符的结果是布尔类型

a,b=10,20
print('a>b吗?',a>b)
print(a<b)
print(a<=b)
print(a>=b)
print(a==b)# false
print(a!=b)# true

a=10
b=10
print(a==b) #True 说明，a与b的value相等
print(a is b) #True 说明：a与b的id标识相等
print(a is not b)# false

lst1=[11,22,33,44]
lst2=[11,22,33,44]
print(lst1==lst2)# true
print(lst1 is lst2 )# false
print(id(lst1))# 2525441564
print(id(lst2))# 2525665484
print(lst1 is not lst2)# true

布尔运算符

a,b=1,2
print(a==1 and b==2)# true
print(a==1 and b<2)# false
print(a!=1 and b==2)# false
print(a!=1 and b!=2)# false

print(a==1 or b==2)# true
print(a==1 or b<2)# true
print(a!=1 or b==2)# true
print(a!=1 or b!=2)# false

#not 对bool类型操作数取反
f=True
f2=False
print(not f)# false
print(not f2)# true

s='helloworld'
print('w' in s)# true
print('k' in s)# false
print('w' not in s)# false
print('k' not in s)# true

位运算

print(4&8) # 输出0。按位与&，同时为1结果为1
print(4|8) # 输出12。按位或|，同时为0结果为0
print(4<<1) # 输出8。向左移动1位 相当于乘以2
print(4<<2) # 输出16。向左移动2位
print(4>>1) # 输出2。向右移动1位，相当于除以二
print(4>>2) # 输出1。除以4

运算符的优先级

总结：()、算术运算、位运算、比较运算、bool运算、赋值运算

1. （）
2. ** A 赋值运算符：先乘除后加减，有幂运算先幂运算
3. *、/、//、%
4. +、-
5. <<、>> B 位运算符
6. &
7. |

8. 、< 、>=、<=、==、！= C 比较运算符

9. and
10. or D 布尔运算符
11. = E 赋值运算符

程序的组织结构

任何简单或者复杂的算法 可以由顺序结构、选择结构（if语句）和循环结构（while for-in语句）组成

顺序结构

程序开始-代码1-代码2-代码3……代码N——程序结束

对象的布尔值

Python一切为对象 所有对象都有一个布尔值
获取对象的布尔值，使用内置函数bool()

#以下对象bool值均为False
print(bool(False))
print(bool(0))
print(bool(0.0))
print(bool(None))
print(bool(''))
print(bool(""))
print(bool([])) #空列表
print(bool(list())) #空列表
print(bool(())) #空元组
print(bool(tuple())) #空元组
print(bool({})) #空字典
print(bool(dict())) #空字典
print(bool(set())) #空集合
#其他对象bool值均为True

分支结构

if 条件表达式:
如果满足条件执行缩进的代码
else:
如果不满足条件执行else里面缩进的代码

#单分支结构
money=1000
s=int(input('请输入取款金额：'))
if money>=s:
    money=money-s
    print('取款成功，余额为：',money)

#双分支结构
num=int(input('请输入一个整数：'))
if num/2==0:
    print(num,'是偶数')
else:
    print(num,'是奇数')

#多分支结构
score=float(input('请输入一个成绩：'))
if 90<=score<=100:
    print('A')
elif 80<=score<90:
    print('B')
elif 70<=score<80:
    print('C')
elif 60<=score<70:
    print('D')
elif 0<=score<60:
    print('E')
else:
    print('不是有效成绩')

#嵌套if的使用
answer=input('您是会员吗?y/n')
money=float(input('请输入您的购物金额：'))
if answer=='y':
    if money>=200:
        print(money*0.8)
    elif money>=100:
        print(money*0.9)
    else:
        print(money)
else:
    if money>=200:
        print(money*0.95)
    else:
        print(money)

条件表达式和pass语句

条件表达式是if……else（简写），语法结构：x if 判断条件 else y，如果判断条件的布尔值为True，条件表达式的返回值为x，否则条件表达式的返回值为y

# 从键盘中输入两个整数，判断两个整数的大小
num1=int(input('请输入第一个整数'))
num2=int(input('请输入第二个整数'))
'''if num1>=num2:
    print(num1,'大于等于',num2)
else:
    print(num1,'小于',num2)'''

print(str(num1)+'大于等于'+str(num2) if num1>=num2 else str(num1)+'小于'+str(num2))

'''
pass语句什么都不做，只是一个占位符，用在需要语句的地方
#使用时间：先搭建语法结构，还没好代码怎么写的时候
配套使用：
1. if 语句的条件执行体
2. for--in语句的循环体
3. 定义函数的函数体 
'''
answer=input('您是会员吗?y/n')
if answer=='y':
    pass
else:
    pass

range()函数的使用

#range()的三种创建方式
# 第一种创建方式
r=range(10) #默认从零开始，默认相差1称为步长
print(r) #range(0,10)
print(list(r)) #用于查看range对象中的整数序列 -->list是列表的意思
# 输出：[0,1,2,3,4,5,6,7,8,9]

# 第二种创建方式
r=range(1,10) #指定起始值，从1开始到10结束(不包含10)
print(list(r))
# 输出：[1,2,3,4,5,6,7,8,9]

#第三种创建方式
r=range(1,10,2) #步长为2
print(list(r))# 输出：[1,3,5,7,9]

# 判断指定的m
print(9 in r)
print(8 not in r)

while循环

sum=0
a=0
while a<5:
    sum+=a
    a+=1
print(sum)

# 1到100之间![请添加图片描述](https://img-blog.csdnimg.cn/abba8fe6d6e248a290c840187f46ef8a.png)
的偶数和
sum=0
a=1
while a<=100:
    if not bool(a%2):             # if a%2==0:
        sum+=a
    a+=1
print(sum)

for_in循环

for item in 'python':
    print(item)
# range()产生的整数序列，也是一个可迭代对象
for i in range(10):
    print(i)
# 如果在循环体中不需要使用到自定义变量，可将自定义变量写为“_“
for _ in range(5):
    print('人生苦短')

# 100到999之间的水仙花数
for item in range(100,1000):
    ge=item%10
    shi=item//10%10
    bai=item//100
    #print(bai,shi,ge)
    if ge**3+shi**3+bai**3==item:
        print(item)

流程控制语句break和continue

a=0
while a<3:
    pwd=input('请输入密码：')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
    a+=1

for item in range (1,51):
    if item%5!=0:
        continue
    print(item)

else语句

与while和for搭配使用：只要循环正常执行完，就会执行else

for item in range(3):
    pwd=input('请输入密码：')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
else:
    print('对不起，三次密码均输入错误')

嵌套循环

for i in range(1,4):  #行表
    for j in range(1,5): 
        print('*',end='\t') #不换行输出
    print()    #打行

for i in range(1,10):
    for j in range(1,i+1):
        print(i,'*',j,'=',i*j,end='\t')
    print()

二重循环的break和continue

二重循环中的break和continue用于控制本层循环

for i in range(5):
    for j in range(1,11):
        if j%2==0:
            #break
            continue
        print(j,end='\t')
    print()

列表

列表的创建

# 列表对象
# 创建列表的第一种方式,[]
lst=['hello','world',98,'hello']
print(id(lst))
print(type(lst))
print(lst)
print(lst[0],lst[-4])
# 创建列表的第二种方式,list()
lst2=list(['hello','world',98])
print(id(lst2))
print(type(lst2))
print(lst2)

列表的特点

获取列表中单个元素

lst=['hello','world',98,'hello']
print(lst.index('hello')) #列表中有相同元素只返回列表中相同元素的的第一个元素的索引
# print(lst.index('python')) #ValueError: 'python' is not in list
# print(lst.index('hello',1,3)) #ValueError: 'hello' is not in list  1-'world' 2-98 不包括3
print(lst.index('hello',1,4))

lst=['hello','world',98,'hello','world',234]
# 获取索引为2的
print(lst[2])
# 获取索引为-3的
print(lst[-3])
# 获取索引为10的
print(lst[10]) # IndexError: list index out of range

获取列表中的多个元素——切片操作

lst=[10,20,30,40,50,60,70,80]
print(lst[1:6:1])# [20,30,40,50,60]
print(lst[1:6]) #默认步长为1 [20,30,40,50,60]
print(lst[1:6:])#默认步长为1 [20,30,40,50,60]
print(lst[1:6:2]) #步长为2 [20,40,60]
print(lst[:6:2])# [10,30,50]
print(lst[1::2])# [20,40,60,80]
print(lst[::2])# [10,30,50,70]
print(lst[::])# [10,20,30,40,50,60,70,80]
# 步长为负数
print(lst[::-1])# [80,70,60,50,40,30,20,10]
print(lst[7::-1])# [80,70,60,50,40,30,20,10]
print(lst[6:0:-2])# [70,50,30]
# 新切出来的是一个新的列表对象
print('原列表',id(lst))# 2005509464960
lst2=lst[1:6:1]
print('切的片段',id(lst2))# 2005510479424

列表元素的判断及遍历

lst=[10,20,'python','hello']
print(10 in lst) #判断
print(10 not in lst)
for item in lst: #遍历
    print(item)

列表元素的增删改操作

列表元素的增加操作

# 向列表末尾添加元素
lst=[10,20,30]
print(lst,id(lst))# 2181409792960
lst.append(100)
print(lst,id(lst))# 2181409792960

lst2=['hello','world']
# lst.append(lst2) # 将lst2作为一个元素添加到列表末尾 [10,20,30,['hello','world']]
lst.extend(lst2) # 向列表末尾添加多个元素 [10,20,30,'hello','world']
print(lst)

lst.insert(1,90) # 在任意位置上添加一个元素，在索引为1的位置上添加一个90
print(lst)# [10,90,20,30,'hello','world']

lst3=[True,False,'hello']
lst[1:]=lst3 # 在任意位置添加N个元素，从第一个元素开始后面的元素全删除（切掉），然后再添加元素
print(lst)# [10,True,False,'hello']

列表元素的删除操作

lst=[10,20,30,40,50,60,30]
lst.remove(30) #从列表中移除一个元素，如果有重复元素只移除第一个元素
print(lst)# [10,20,40,50,60,30]
# lst.remove(100) #ValueError: list.remove(x): x not in list

#pop()根据索引移除元素
lst.pop(1)
print(lst)# [10,40,50,60,30]
# lst.pop(5) #IndexError: pop index out of range
lst.pop() #如果不指定参数，将删除最后一个参数
print(lst)# [10,40,50,60]

# 切片操作会产生一个新的列表对象，切片相当于从列表中取数
new_lst=lst[1:3]
print('原列表',lst)# [10,40,50,60]
print('切片后列表',new_lst)# [40,50]
# 不产生新的列表对象，而是删除原列表中的内容
lst[1:3]=[]
print(lst)# [10,60]

lst.clear() #清除列表中的所有元素
print(lst)
del lst #将列表对象删除
# print(lst) # NameError: name 'lst' is not defined. Did you mean: 'list'?

列表元素的修改操作

#修改一个值
lst=[10,20,30,40]
lst[2]=100 
print(lst)# [10,20,100,40]
# 使用切片修改多个值
lst[1:3]=[300,400,500,600]
print(lst)# [20,300,400,500,600,40]

列表元素的排序操作

lst=[20,40,10,98,54]
print('排序前',lst,id(lst))# [20,40,10,98,54] 1632705897408
lst.sort() #升序
print('排序后',lst,id(lst))# [10,20,40,54,98] 1632705897408
# 指定关键字参数，实现列表元素的降序排序
lst.sort(reverse=True) #降序
print(lst)# [98，54，40，20，10]
lst.sort(reverse=False) #升序
print(lst)# [10,20,40,54,98]

# 使用内置函数sorted()对列表进行排序，将产生一个新的列表
lst=[20,40,10,98,54]
new_lst=sorted(lst) #产生一个新列表 升序
print(lst)# [20,40,10,98,54]
print(new_lst)# [10,20,40,54,98]
# 指定关键字参数，实现列表元素的降序排序
desc_lst=sorted(lst,reverse=True) #降序
print(desc_lst)# [98，54，40，20，10]

列表生成式

lst=[i*i for i in range(1,10)]
print(lst)
lst2=[i for i in range(2,11,2)]
print(lst2)

字典

可变序列：能够进行增删改的序列
列表是有序序列

key是不可变序列，如str，不可变序列不可执行增删改操作

字典的创建

使用内置函数dict()是通过赋值的形式创建字典，所以左侧不加‘’，右侧加不加根据右侧的数据类型来定

# 使用花括号
scores={'张三':100,'李四':98,'王五':45}
print(scores)
# 使用内置函数
stu=dict(name='jack',age=20)
print(stu)

字典的常用操作

字典元素的获取

# 获取字典中的值,使用[]
print(scores['张三'])
# print(scores['陈六']) # KeyError: '陈六'
# 使用get()
print(scores.get('张三'))
print(scores.get('陈六')) # None
# 如果查找的key不存在，返回某个默认值
print(scores.get('马七',99)) # 99是在查找‘马七’所对的value不存在时，提供的一个默认值

字典元素的增删改操作

scores={'张三':100,'李四':98,'王五':45}
print("张三" in scores)# true
print("张三" not in scores)# false
del scores['张三'] # 删除指定的key-value对，输出：{'李四':98,'王五':45}
# scores.clear() # 清空字典的元素
print(scores)
scores['陈六']=98 #新增元素
print(scores)# {'李四':98,'王五':45,'陈六':98}
scores['陈六']=100 # 修改元素
print(scores)# {'李四':98,'王五':45,'陈六':100}

获取字典视图

scores={'张三':100,'李四':98,'王五':45}
# 获取所有的key
keys=scores.keys()
print(keys)# dict_keys(['张三','李四','王五'])
print(type(keys))# dict_keys
# scores.keys()得到的数据的类型是dict_keys，我们可以将所有的key组成的视图转成列表
print(list(keys))# ['张三','李四','王五']

# 获取所有的value
values=scores.values()
print(values)# dict_values([100,98,45])
print(type(values))# dict_values
print(list(values))# [100,98,45]

#获取所有的key-value对
items=scores.items()
print(items)# dict_items([('张三':100),('李四':98),('王五':45)])
print(list(items)) # 转换之后的列表元素是由元组组成:[('张三':100),('李四':98),('王五':45)]

字典元素的遍历

item是遍历出来的键的名称，score是要遍历的字典的名称

scores={'张三':100,'李四':98,'王五':45}
# 字典元素的遍历
for item in scores:
    print(item,scores[item],scores.get(item))

字典的特点

d={'name':'张三','name':'李四'} # key不允许重复，重复的key会覆盖原来的值
print(d)# {'name':'李四'}
d={'name':'张三','nikename':'张三'} # value允许重复
print(d)# {'name':'李四','name':'张三','nikename':'张三'}

字典生成式

items=['Fruits','Books','Others']
prices=[96,78,85,100,120]
# 遍历两个list中的值，分别存放在item,price中，item,price是要放在字典中的，所以最外层用了{}，里面写作item:price，如果想要items大写，那么使用item.upper()
d={item.upper():price   for item,price in zip(items,prices)}
print(d)# 当两个list的个数不一致时，以短的那个为准
lst=zip(items,prices)
print(list(lst))

元组

'''可变序列 列表，字典：可以进行增删改，即列表/字典进行增删改后，列表/字典在内存中的地址不变'''
lst=[10,20,45]
print(id(lst))# 1808459865024
lst.append(200)
print(id(lst))# 1808459865024
'''不可变序列 字符串，元组：不可以进行增删改，
即不可变序列进行增删改并非在原序列上操作，而是在内存中新开辟一个序列，所以不可变序列进行增删改后在内存中的地址会改变'''
s='hello'
print(id(s))# 2753280992112
s=s+'world'
print(id(s))# 2753284295600
print(s)

元组的创建方式

# 第一种，用()
t=('Python','world',98)
print(t)# ('Python','world',98)
print(type(t))# tuple

t2='Python','world',98 # 省略了小括号
print(t2)# ('Python','world',98)
print(type(t2))# tuple

t=('Python',) # 只包含一个元组的元素需要使用逗号和小括号，不然为str类型(此处)
print(t)# ('Python')
print(type(t))# tuple

# 第二种创建方式，内置函数tuple()
t1=tuple(('Python','world',98))
print(t1)# ('Python','world',98)
print(type(t1))# tuple

# 空列表
lst=[]
lst1=list()
# 空字典
d={}
d1=dict()
# 空元组
t=()
t1=tuple()
print('空列表',lst,lst1)
print('空字典',d,d1)
print('空元组',t,t1)

为什么要将元组设计成不可变序列

一旦创建了不可变类型的对象，对象内的所有数据就不能再被修改了，这就避免了由于修改数据而导致的错误。此外对于不可变类型的对象，在多任务环境下，同时操作对象时不需要加锁

元组中保存的数据为(10,[20,30],9)，10和9都是不可变对象，不能引用其他值，如果我想把[20,30]位置的数据换成100，这也是不可以的，因为[20,30]是可变对象，可变对象的引用不可以改变，只能在[20,30]后面追加100，元组中原本指向[20,30]的内存地址不变

t=(10,[20,30],9)
print(type(t))# tuple
print(t[0],type(t[0]),id(t[0]))# 10 int 140716189915072
print(t[1],type(t[1]),id(t[1]))# [20,30] list 2223714708224
print(t[2],type(t[2]),id(t[2]))# 9 int 140716189915040
# 尝试将t[1]修改为100
print(id(100))# 140716189917952
#t[1]=100 #元组不允许修改元素
#由于[20,30]列表，而列表是可变序列，所以可以向列中添加元素，而列表的内存地址不变
t[1].append(100) #向列表中添加元素
print(t,id(t[1]))# [20,30,100] 2223714708224

元组的遍历

#元组的遍历
t=('Python','world',98)
#1.索引
print(t[0])
print(t[1])
print(t[2])
# print(t[3]) #IndexError: tuple index out of range
#2.遍历
for item in t:
    print(item)

集合

# 集合的创建方式
# 1.{}
s={2,3,4,5,6,7,7} #集合中的元素不允许重复
print(s)# {2,3,4,5,6,7}

#2.set()
s1=set(range(6))
print(s1,type(s1))# {0,1,2,3,4,5} set
# 通过set()将列表中的元素转成集合
s2=set([1,2,4,5,5,5,6,6])
print(s2,type(s2))# {1,2,3,5,6} set
# 通过set()将元组中的元素转成集合
s3=set((1,2,4,4,5,65)) #集合中的元素是无序的
print(s3,type(s3))# {1,2,4,5,65} set
# 通过set()将字符串中的元素转成集合
s4=set('python')
print(s4,type(s4))# {'n','h','p','y','t','y'} set
# 通过set()将字典中的元素转成集合
s5=set({12,4,34,55,66,44,4})
print(s5,type(s5))# {34,66,4,55,12,44} set

# 定义一个空集合
s6={} #dict字典类型
print(type(s6))# dict
s7=set()
print(type(s7))# set

集合的相关操作

#集合的相关操作
#判断操作
s={10,2,0,30,40,50}
print(10 in s)# true
print(100 in s)# false
print(0 not in s)# false
#新增操作
s.add(80) #一次添加一个
print(s)# {10,80,2,30,0,40,50}，无序的
s.update({200,300,4000}) #一次至少添加一个元素，把一个集合添加到指定集合中
print(s)# {200,300,10,80,2,30,0,40,50,4000}，无序的
# 也可以以列表和元组的形式批量往里添加数据
s.update([100,99,6])
s.update((78,56,48))
print(s)# {78,200,56,300,10,100,80,48,2,6,30,0,40,99,50,4000}

#删除操作
s.remove(10)
print(s)# {78,200,56,300,100,80,48,2,6,30,0,40,99,50,4000}
# s.remove(500) #KeyError: 500
# print(s)
# 如果集合中有500则删除，没有也不报错
# s.discard(500) #没有，不报错
# print(s)
s.pop() #只能删除第一个，且不能添加参数
print(s)# {200,56,300,10,100,80,48,2,6,30,0,40,99,50,4000}
s.clear() #清空集合
print(s)# set()

集合间的关系

# 两个集合是否相等(元素相同，就相等)
s={10,20,30,40}
s2={20,30,40,10}
print(s==s2) #T
print(s!=s2) #F
#子集和超集
s1={10,20,30,40,50,60}
s2={10,20,30,40}
s3={10,20,90}
print(s2.issubset(s1)) #T s2的所有数据都在s1中，所以s2是s1的子集
print(s3.issubset(s1)) #F 
print(s1.issuperset(s2)) #T s2的所有数据都在s1中，所以s1是s2的超集
print(s1.issuperset(s3)) #F
#交集
print(s2.isdisjoint(s3)) #F - 有交集
s4={100,200,300}
print(s2.isdisjoint(s4)) #T - 没有交集

集合的数据操作

# 集合的数学操作
#(1)交集
s1={10,20,30,40}
s2={20,30,40,50,60}
print(s1.intersection(s2))# {40,30,20}
print(s1&s2)# &与intersection等价，都是求交集操作，输出：{40,30,20}

#(2)并集
print(s1.union(s2))# {40,30,20,10,50,60}
print(s1|s2)# |与union等价，都是求并集操作，输出：{40,30,20,10,50,60}

#(3)差集
print(s1.difference(s2)) #s1有s2没有，输出：[10]
print(s1-s2)# -与difference等价，都是求差集操作，输出：[10]
print(s2.difference(s1))# s2有s1没有，输出：[50,60]

#(4)对称差集
print(s1.symmetric_difference(s2)) #集合交集以外的元素，输出：[10,50,60]
print(s1^s2)# ^与symmetric_difference等价，都是求对称差集操作，输出：[10,50,60]

集合生成式

s={i*i for i in range(10)}
print(s)

总结

字符串

字符串的创建和驻留机制

#字符串
#字符串的定义及驻留机制
a='python'
b="python"
c='''python'''
print(a,id(a))# python 1874508798960
print(b,id(b))# python 1874508798960
print(c,id(c))# python 1874508798960

驻留机制：仅保存一份相同且不可变的字符串的方式

交互模式：cmd下执行python即可进入交互模式
符合标识符的字符串：含有字母数字下划线的字符串


b是在程序编译时完成了拼接，c是在程序运行时使用join完成拼接，a is c为false
可以使用sys实现强制驻留

字符串的常用操作

字符串的查询操作

#字符串查询操作
s='hello,hello'
print(s.index('lo')) #第一次出现的位置，输出：3
print(s.find('lo'))#第一次出现的位置，输出：9
print(s.rindex('lo')) #最后一次出现的位置
print(s.rfind('lo'))#第一次出现的位置，输出：9

# print(s.index('k')) #ValueError: substring not found 不存在
print(s.find('k')) #-1 不存在

字符串的大小写转换

#字符串的大小写转换操作
s='HelloWorld,wa'
print(s.upper(),id(s.upper())) #全转成大写会产生一个新的字符串对象，输出：HRLLOWORLD,WA 2133868981488
print(s,id(s))#helloworld,wa 2134125876016
print(s.lower()) #全转成小写，如果原来的字符串就是小写的，在执行了lower()后依旧会产生一个新的字符串对象，二者的id()依旧不一样
print(s.swapcase()) #大转小，小转大
print(s.capitalize()) #第一个字符大写，其余小写
print(s.title()) #每个单词首字母大写，其余小写

字符串内容对齐操作

#字符串内容对齐操作
s='hello,Python'
#居中对齐
print(s.center(20,'*')) #****hello,Python****
#左对齐
print(s.ljust(20,'*')) #hello,Python********
print(s.ljust(10))#hello,Python
print(s.ljust(20))#hello,Python        
#右对齐
print(s.rjust(20,'*'))#********hello,Python
print(s.rjust(20))#        hello,Python
print(s.rjust(10))#hello,Python
#右对齐，左边用0填充
print(s.zfill(20))#00000000hello,Python
print(s.zfill(10))#hello,Python
print('-8910'.zfill(8))#-0008910

字符串的劈分操作

#字符串的劈分操作
s='hello world Python'
print(s.split())# 默认以空格拆分，输出：['hello','world','Python']
s1='hello|world|Python'
print(s1.split())# ['hello world Python']
print(s1.split(sep='|'))# 指定分隔符，['hello','world','Python']
print(s1.split(sep='|',maxsplit=1))#['hello','world｜Python'] 
#从右侧分
print(s1.rsplit(sep='|',maxsplit=1))# ['hello｜world','Python']

字符串的判断操作

#字符串判断的相关方法
#合法标识符
s='hello,python'
print(s.isidentifier()) #F
print('hello'.isidentifier()) #T
print('张三_123'.isidentifier()) #T
#空白字符
print('\t'.isspace()) #T
print(' '.isspace()) #T
#字母
print('abc'.isalpha()) #T
print('张三'.isalpha()) #T
print('张三1'.isalpha()) #F
#十进制数字
print('123'.isdecimal()) #T
print('123四'.isdecimal()) #F
print('ⅡⅢⅣ'.isdecimal()) #F
#数字
print('123'.isnumeric()) #T
print('123四'.isnumeric()) #T
print('ⅡⅢⅣ'.isnumeric()) #T
print('壹贰叁'.isnumeric()) #T
#字母和数字
print('abc1'.isalnum()) #T
print('张三123'.isalnum()) #T
print('abc!'.isalnum()) #F

字符串的其他操作

#字符串的其他操作
#字符串的替换
s='hello,Python'
print(s.replace('Python','Java'))# 用Java替换python，输出：hello,Java
s1='hello,Python,Python,Python'
print(s1.replace('Python','Java',2)) #第三个次数指定替换次数，输出hello,Java,Java,Python
#字符串的合并
# 连接数组元素
lst=['hello','java','python']
print('|'.join(lst))# hello｜java｜python
print(''.join(lst))# hellojavapython
# 连接元组元素
t=('hello','java','python')
print(''.join(t))# hellojavapython
# 连接字符串的元素
print('*'.join('python'))# p*y*t*h*o*n

字符串的比较操作

#字符串的比较操作
print('apple'>'app') #T
print('apple'>'banana') #F, 97>98 F
print(ord('a'),ord('b')) #原始值这里是字母的ascll码
print(ord('刘'))
print(chr(97),chr(98))# 获取ascii码为97的值，即a。chr()和ord()互为相反的两个方法
print(chr(21016))

'''==和is的区别
==比较的是value
is 比较的是 id'''
a=b='python'
c='python'
print(a==b) #T
print(b==c) #T
print(a is b) #T
print(a is c) #T
print(id(a)) #2383540093936
print(id(b)) #2383540093936
print(id(c)) #2383540093936

字符串的切片操作

#字符串的切片操作
s='hello,python'
print(s[:5]) #没有指定起始位置，从0开始，输出：hello
print(s[6:]) #没有指定结束位置，所以切到字符串最后一个元素，输出：python
s1='!'
newstr=s[:5]+s1+s[6:]
print(newstr) # hello！python
print(id(s))# 1990114866608
print(id(s[:5]))# 1990110831472
print(id(s[6:]))# 1990110735152
print(id(s1))# 1989860883760
print(id(newstr))# 1990110735216

print(s[1:5:1]) #完整写法 从一切到四，步长为一，输出：ello
print(s[::2]) #从0开始切到最后，输出：hlopto
print(s[::-1]) #从最后一个元素开始往前到第一个元素，步长为1，输出：nohtyp,olleh
print(s[-6::1])#从索引为-6的开始，到字符串的最后一个元素，步长为1，输出：python

格式化字符串

格式化字符串：按一定格式输出的字符串

#格式化字符串
# % 占位符
name='张三'
age=20
print('我叫%s,今年%d岁' % (name,age))
# {}，0代表取format的第一个参数，所有用到0的地方都使用这个参数的值
print('我叫{0},今年{1}岁,我真的叫{0}'.format(name,age))
# f-string，前面加f代表格式化字符串
print(f'我叫{name},今年{age}岁')

#宽度和精度
print('%10d' % 99) #10个宽度，输出：          99
print('%.3f' % 3.1415926) #.3表示小数点后三位，输出：3.142
print('%10.3f' % 3.1415926) #宽度为10，保留三位小数，输出：          3.142
print('hellohello')
# 下面的0均指format第一个参数
print('{0:.3}'.format(3.1415926)) #.3表示一共三位数，输出：3.14
print('{0:.3f}'.format(3.1415926)) #.3f表示3位小数，输出：3.142
print('{0:10.3f}'.format(3.1415926)) #宽度是10位，3位是小数，输出

字符串的编码转换

#字符串的编码转换
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')) #解码
byte=s.encode(encoding='UTF-8')
print(byte.decode(encoding='UTF-8'))

函数

函数的定义与调用

#函数的定义和调用
def calc(a,b):  #a,b为形式参数，形参位置是在函数的定义处
    c=a+b
    return c

result=calc(10,20)  #10,20称为实际参数的值，实参的位置是函数的调用处
print(result)

#函数参数的传递
res=calc(b=10,a=20)  #=左边的变量名称为 关键字参数
print(res)

#函数参数传递的内存分析
def fun(arg1,arg2):
    print('arg1=',arg1)
    print('arg2=',arg2)
    arg1=100
    arg2.append(10)
    print('arg1=',arg1)
    print('arg2=',arg2)

n1=11
n2=[22,33,44]
print('n1=',n1)
print('n2=',n2)
print('-------')
fun(n1,n2)
print('n1=',n1)
print('n2=',n2)

'''在函数调用过程中,进行参数的传递
如果是不可变对象,在函数体的修改不会形象实参的值 arg1修改为100,不会影响n1的值
如果是可变对象，在函数体的修改会影响到实参的值 arg2的修改,append(10),会影响到n2的值'''

函数的返回值

#函数的返回值
def fun(num):
    odd=[]
    even=[]
    for i in num:
        if i % 2: #bool(0)=False
            odd.append(i)
        else:
            even.append(i)
    return odd,even

print(fun([10,29,34,23,44,53,55]))

'''
(1)如果函数没有返回值【函数执行完毕后，不需要给调用处提供数据】 return可以省略
(2)如果函数有一个返回值，直接返回原类型
(3)如果函数有多个返回值，返回结果为元组
'''
def fun1():
    print('hello')
    #return

fun1()

def fun2():
    return 'hello'

res=fun2()
print(res)

def fun3():
    return 'hello','world'

print(fun3())
'''函数在定义时，是否需要返回值，视情况而定'''

函数参数定义

#默认值参数
def fun(a,b=10):  #b为默认值
    print(a,b)

#函数的调用
fun(100)# 100，10
fun(20,30)# 20，30

查看print的源码发现：

这个end就是默认值参数，默认换行，如果你不想换行，可以给end传其他值：

print('hello',end='\t')
print('world')
# 输出：hello world

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

fun(10)
fun(10,20,30)

def fun1(**args): #个数可变的关键字参数
    print(args)

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

''' def fun2(*args,*a):
       pass
    报错，个数可变的位置参数，只能是一个
    def fun2(*args,*a):
        pass
    报错，个数可变的关键字参数，只能是一个'''

def fun2(*args1,**args2):
    pass

''' def fun3(**args1,*args2):
        pass
在一个函数定义的过程中，既有个数可变的关键字参数，也有个数可变的位置形参，要求个数可变的位置形参，放在个数可变的关键字形参之前'''

#函数参数总结
def fun(a,b,c):  # a,b,c在函数的定义处，所以是形式参数
    print('a=',a)
    print('b=',b)
    print('c=',c)

#函数的调用
fun(10,20,30)  #函数调用时的参数传递，称为位置传参
'''
输出：
a=10
b=20
c=30
'''
lst=[11,22,33]
fun(*lst)  #函数调用时，将列表的每个元素都转换为位置实参传入
'''
输出：
a=11
b=22
c=33
'''
print('--------')
fun(a=100,c=300,b=200)  #关键字实参
'''
输出：
a=100
b=200
c=300
'''
dic={"a":111,'b':222,'c':333}
fun(**dic)  #在函数调用时，将字典的键值对都转换为关键字实参传入
'''
输出：
a=111
b=222
c=333
'''
def fun4(a,b,*,c,d):  #从*之后的参数，在函数调用时，只能采用关键字参数传递
    print('a=',a)
    print('b=',b)
    print('c=',c)
    print('d=',d)

#fun4(10,20,30,40) #位置实参传递
fun4(a=10,b=20,c=10,d=40) #关键字实参传递
fun4(10,20,c=30,d=40) #前两个位置实参传递，后两个关键字实参传递

'''函数定义时形参的顺序问题'''
def fun5(a,b,*,c,d,**args):
    pass
def fun6(*args,**args1):
    pass
def fun7(a,b=10,*args,**args1):
    pass

变量的作用域

#变量的作用域
def fun(a,b):
    c=a+b  #c,就称为局部变量，因为c在函数体内进行定义的变量，a，b为函数的形参，作用范围也是函数内部，相当于局部变量 
    print(c)

name='刘'   #全局变量
print(name)
def fun1():
    print(name)
fun1()

def fun3():
    global age  #函数内部定义的变量，局部变量，其用global声明，这个变量变为全局变量
    age=20
    print(age)
fun3()
print(age)

递归函数

#递归函数
def fac(n):
    if n==1:
        return 1
    else:
        return n*fac(n-1)

print(fac(9))

#斐波那契数列
def fib(n):
    if n==1:
        return 1
    elif n==2:
        return 1
    else:
        return fib(n-1)+fib(n-2)

print(fib(6))

for i in range(1,7):
    print(fib(i))

bug

#bug的常见类型
#1.
age=input('请输入你的年龄：')
print(type(age))
# if age>=18:  #TypeError: '>=' not supported between instances of 'str' and 'int'
if int(age)>=18:
    print('你是成年人了')

#2.
# while i<10:
#     print（i）
i=0
while i<10:
    print(i)
    i+=1

#3.
for i in range(3):
    uname=input('请输入用户名：')
    pwd=input('请输入密码：')
    # if uname='admin' and pwd='admin':
    if uname=='admin' and pwd=='admin':
        print('登陆成功！')
        break
    # else
    else:
        print('输入有误')
else:
    print('对不起，三次均输入错误')

#4.索引越界问题IndexError
lst=[11,22,33,44]
# print(lst[4])  #list index out of range
print(lst[3])

#5.append()方法的使用不熟练
lst=[]
# lst=append('A','B','C')
lst.append('A')
lst.append('B')
lst.append('C')
print(lst)

#被动掉坑问题
''' n1=int(input('请输入一个整数：'))
    n2=int(input('请输入另一个整数：'))
    result=n1/n2
    print('结果为：',result)'''

python的异常机制：try…exception

当存在多个异常需要捕获时，可以采用多个except结构：

#try...except结构
try:
    n1=int(input('请输入一个整数：'))
    n2=int(input('请输入另一个整数：'))
    result=n1/n2
    print('结果为：',result)
except ZeroDivisionError:
    print('对不起，除数不允许为零')
except ValueError:
    print('不能将字符转换为数字')
print('程序结束')

#try...except...else结构
try:
    n1=int(input('请输入一个整数：'))
    n2=int(input('请输入另一个整数：'))
    result=n1/n2
except BaseException as e:
    print('出错了',e)
else:
    print('结果为：',result)

#try...except...else...finally结构
try:
    n1=int(input('请输入一个整数：'))
    n2=int(input('请输入另一个整数：'))
    result=n1/n2
except BaseException as e:
    print('出错了',e)
else:
    print('结果为：',result)
finally:
    print('谢谢您的使用')
print('程序结束')

python中常见的异常类型

#常见的异常类型
# print(10/0)  #ZeroDivisionError

lst=[11,22,33,44]
# print(lst[4])  #IndexError

dic={'name':'张三','age':20}
# print(dic['gender'])  #KeyError

# print(num)  #NameError

# int a=20  #SyntaxError

#a=int('hello')  #ValueError

traceback模块的使用

#traceback模块的使用
import traceback
try:
    print('--------------')
    print(1/0)
except:
    traceback.print_exc()

对象

python中一切皆对象

类的创建

实例方法写不写self都会有个self在（不写程序白送你一个），静态方法中不允许写self，类方法中需要传入cls

#定义python中的类
class Student:  #Student为类的名称（类名）由一个或多个单词组成，每个单词首字母大写，其余小写
    native_place='吉林'  #直接写在类里的变量，成为类属性
    def __init__(self,name,age):
        self.name=name  #self.name 称为实例属性，进行了一个赋值操作，将局部变量的name的值赋给实体属性/实例变量
        self.age=age
    #实例方法
    def eat(self):
        print(self.name+'在吃饭')
    #静态方法
    @staticmethod
    def sm():
        print('静态方法')
    #类方法
    @classmethod
    def cm(cls):
        print('类方法')
#在类之外定义的称为函数，再类之内定义的称为方法
def drink():
    print('喝水')

#创建Student类的对象
stu1=Student('张三',20)
stu2=Student('李四',30)
print(id(stu1))# 1421362237888
print(type(stu1))# <class '__main__.Student'>
print(stu1)# <__main__.Student object at 0x0000014AEFCA91C0>
# 1421362237888的十六进制为0x0000014AEFCA91C0
# 实例对象会有一个类指针指向类对象
print(id(Student))# 2218905389200
print(type(Student))# <class ‘type’>
print(Student)# <class '__main__.Student'>
# 下面两行都可以调用类的实例方法：实例对象.实例方法 或者 类对象.实例方法(实例对象)
stu1.eat()  #对象名.方法名()
Student.eat(stu1)  #类名.方法名(类的对象)-->实际上就是方法定义处的self
print(stu1.name)
print(stu1.age)

#类属性的使用方式
#print(Student.native_place)
print(stu1.native_place)# 吉林
print(stu2.native_place)# 吉林
Student.native_place='天津'
print(stu1.native_place)# 天津
print(stu2.native_place)# 天津
#类方法的使用方式
Student.cm()
#静态方法的使用方式
Student.sm()

#动态绑定属性和方法
stu2.gender='女'  #动态绑定性别属性
# print(stu1.name,stu1.age,stu1.gender)  #AttributeError: 'Student' object has no attribute 'gender'
print(stu2.name,stu2.age,stu2.gender)
stu1.eat()
stu2.eat()
def show():
    print('定义在类之外的，称为函数')
stu1.show=show  #动态绑定方法
stu1.show()
# stu2.show()  #AttributeError: 'Student' object has no attribute 'show'

面向对象的三大特征

封装

#封装
class Car:
    def __init__(self,brand):
        self.brand=brand
    def start(self):
        print('汽车已启动...')

car=Car('宝马x5')
car.start()
print(car.brand)

class Student:
    def __init__(self,name,age):
        self.name=name
        self.__age=age  #年龄不希望在类的外部被使用，所以加__
    def show(self):
        print(self.name,self.__age)

stu=Student('张三',20)
stu.show()
#在类的外部使用name和age
print(stu.name)
# print(stu.__age)  #AttributeError: 'Student' object has no attribute '__age'
# print(dir(stu))  #获取对象所有的属性和方法
print(stu._Student__age)  #在类的外部可以通过 _Student__age 进行访问，输出：20

继承

定义类时，括号里写父类，如上述Person的父类是object，Student的父类是Person。python支持多继承，比如a继承object，b继承object，c可以同时继承a,b：class c(a,b)

#继承
class Person(object):
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def info(self):
        print(self.name,self.age)
#定义子类
class Student(Person):
    def __init__(self, name, age,score):
        super().__init__(name, age)# 在子类的init方法中使用super().__init__调用父类的初始化方法进行赋值
        self.score=score# 然后再对自己内部的属性进行初始化
    def info(self):  #方法的重写，重写父类的info()
        super().info()# 如果还想用到父类的info()的方法体，使用super().info()调用
        print(self.score)
class Teacher(Person):
    def __init__(self, name, age,teachofyear):
        super().__init__(name, age)
        self.teachofyear=teachofyear
    def info(self):  #方法的重写
        super().info()
        print(self.teachofyear)
#测试
stu=Student('Jack',20,'1001')
stu.info()
tea=Teacher('Tom',40,20)
tea.info()

object类

#object类 -- 所有类的父类
class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __str__(self):
        return '我的名字是{0}，今年{1}岁'.format(self.name,self.age)

stu=Student('jack',20)
print(dir(stu))
print(stu)# 默认会调用__str__(self)方法，如果没有覆写，会输出实例对象的内存地址![请添加图片描述](https://img-blog.csdnimg.cn/23447cbce6124d0199d04855c30fdbfb.png)

print(type(stu))

多态

像Java这种静态语言实现多态需要具备三个必要条件：继承、方法重写、父类指向子类对象，但是python是动态语言，他只关心你有没有这个方法，其余都不管

#多态
class Animal(object):
    def eat(self):
        print('动物会吃')
class Dog(Animal):
    def eat(self):
        print('狗吃骨头')
class Cat(Animal):
    def eat(self):
        print('猫吃鱼')
class Person:
    def eat(self):
        print('人吃五谷杂粮')
#定义一个函数
def fun(obj):
    obj.eat()
#调用
fun(Cat())# 动物会吃
fun(Dog())
fun(Animal())
fun(Person())

特殊方法和特殊属性

#特殊属性
class A:
    pass
class B:
    pass
class C(A,B):
    def __init__(self,name,age):
        self.name=name
        self.age=age
class D(A):
    pass
#创建C类对象
x=C('jack',20)  #x是C类型的一个实例对象
print(x.__dict__)  #查看实例对象的属性字典
print(C.__dict__)# 查看类对象的属性字典
print(x.__class__)  #输出对象所属的类型 <class '__main__.C'>
print(C.__bases__)  #C类的父类类型的元组：(<class '__main__.A'>,<class '__main__.B'>)
print(C.__base__)  #类的基类，C继承A和B，所以输出<class '__main__.A'>，如果C继承B和A，则输出<class '__main__.B'>，C多继承时，谁在前就输出谁
print(C.__mro__)  #类的层次结构：(<class '__main__.C'>,<class '__main__.A'>,<class '__main__.B'>,<class 'object'>)
print(A.__subclasses__())  #子类的列表:[<class '__main__.C'>,<class '__main__.D'>]

#类的特殊方法
a=20
b=100
c=a+b  #两个整数类型的对象的相加操作
d=a.__add__(b)# 两个整数类型的对象的相加操作，底层调用的是__add__()进行相加
print(c)# 120
print(d)# 120

class Student:
    def __init__(self,name):
        self.name=name
stu1=Student('张三')
stu2=Student('李四')
s=stu1+stu2  #报错：Student类型不能进行相加，但是我想要相加怎么办呢？给Student类定义一个__add__()方法，如下所示
print(len(stu1))# 同理，如果我想输出长度，也会报错，但是我又想输出怎么办呢？给Student类定义一个__len__()方法，如下所示

class Student:
    def __init__(self,name):
        self.name=name
    def __add__(self,other):  #特殊方法
        return self.name+other.name
    def __len__(self):
        return len(self.name)
stu1=Student('张三')
stu2=Student('李四')
s=stu1+stu2  #实现两个对象的加法运算
print(s)# 张三李四
s=stu1.__add__(stu2)
print(s)# 张三李四

lst=[11,22,33,44]
print(len(lst))# 4，调用len(lst)时底层执行了lst.__len__()
print(lst.__len__())# 4
print(len(stu1))# 2

__new__和__init__创建对象的过程

class Person(object):
    def __new__(cls,*args,**kwargs):
        print('__new__被调用执行了,cls的id值为{0}'.format(id(cls)))
        obj=super().__new__(cls)
        print('创建的对象的id为:{0}'.format(id(obj)))
        return obj        
    
    def __init__(self,name,age):
        print('__init__被调用了,self的id值为:{0}'.format(id(self)))
        self.name=name
        self.age=age

print('object这个类对象的id为:{0}'.format(id(object)))
print('Person这个类对象的id为:{0}'.format(id(Person)))

#创建person类的实例对象
p1=Person('张三',20)
print('p1这个Person类的实例对象的id:{0}'.format(id(p1)))

'''
程序的执行结果：
object这个类对象的id为:140717796113232
Person这个类对象的id为:2690679899360
__new__被调用执行了,cls的id值为2690679899360
创建的对象的id为:2690436007104
__init__被调用了,self的id值为:2690436007104
p1这个Person类的实例对象的id:2690436007104
'''

类的浅拷贝与深拷贝

#类的浅拷贝与深拷贝
class CPU:
    pass
class Disk:
    pass
class Computer:
    def __init__(self,cpu,disk):
        self.cpu=cpu
        self.disk=disk

#(1)变量的赋值
cpu1=CPU
cpu2=cpu1
print(cpu1)# <__main__.CPU object at 0x000002B4D38D8490>
print(cpu2)# <__main__.CPU object at 0x000002B4D38D8490>
#(2)类的浅拷贝
disk=Disk()  #创建一个硬盘类的对象
computer=Computer(cpu1,disk)  #创建一个计算机类的对象

#浅拷贝
import copy
print(disk)# <__main__.Disk object at 0x000001782E443490>
computer2=copy.copy(computer)
print(computer,computer.cpu,computer.disk)# <__main__.Computer object at 0x000001781F3284C0> <__main__.CPU object at 0x000001781F238490> <__main__.Disk object at 0x000001782E443490>
print(computer2,computer2.cpu,computer2.disk)# <__main__.Computer object at 0x000001781F328190> <__main__.CPU object at 0x000001781F238490> <__main__.Disk object at 0x000001782E443490>

#深拷贝
computer3=copy.deepcopy(computer)
print(computer,computer.cpu,computer.disk)# <__main__.Computer object at 0x000001813E8284C0> <__main__.CPU object at 0x000001813E738490> <__main__.Disk object at 0x000001814D913490>
print(computer3,computer3.cpu,computer3.disk)# <__main__.Computer object at 0x000001813E8281F0> <__main__.CPU object at 0x000001814D943A30> <__main__.Disk object at 0x000001814EA626A0>

模块

import math
print(id(math))
print(type(math))
print(math)
print(math.pi)
print(dir(math))
print(math.pow(2,3))
print(math.ceil(9.001))
print(math.floor(9.999))

from math import pi
# from math import pow
print(pi)
print(pow(2,3))
# print(math.pow(2,3))

假如我现在自定义了一个模块calc.py，我想在demo5.py模块中导入他，如果我直接写import calc会报错，需要将demo5.py所在包设为source root

以主程序方式运行

假如定义了一个calc2.py，内容如下：

def add(a,b):
    return a+b

print(add(10,20))

然后在demo7.py中引入了他，并执行了print(calc2.add(100,200))，会打印输出30 300，因为他先执行了calc2.py的打印，如果我们只想输出300，不让他执行calc2.py的打印输出，可以这样：

def add(a,b):
    return a+b

if __name__ == '__main__':  #只有在这个模块运行时，才执行下述代码
    print(add(10,20))

python中的包

一个python程序中有无数个包，每个包中有无数个模块，每个模块中又有无数的类、方法、语句。python中创建包：

在demo8.py中导入包中的模块

python中常用的内容模块

import sys
import time
import urllib.request
import math
print(sys.getsizeof(24))# 28:24占了28个字节
print(sys.getsizeof(45))# 28
print(sys.getsizeof(True))# 28
print(sys.getsizeof(False))# 24
print(time.time())
print(time.localtime(time.time()))
print(urllib.request.urlopen('http://www.baidu.com').read())
print(math.pi)

第三方模块的安装及使用

#第三方模块的安装  pip install 模块名
import schedule
import time

def job():
    print('hh')

schedule.every(3).seconds.do(job)
while True:
    schedule.run_pending()
    time.sleep(1)

文件

编码格式

在操作中文文本文件时，经常出现乱码情况，

文件的读取原理

解释器调用操作系统的资源读取.py文件操作磁盘上的文件（对文件进行读写操作）

a.txt的内容为：

中国
美丽

#读
file=open('a.txt','r')
print(file.readlines())# ['中国\n','美丽']，输出一个数组
file.close()

向b.txt文件写入hello

# 写
file=open('b.txt','w')# 如果没有b.txt文件则创建，如果有b.txt文件，因为第二个参数传的w，所以会清除文件原有的内容，重新写入新内容
file.write('hello')
file.close()
#追加
file=open('b.txt','a')# 如果没有b.txt文件则创建，如果有b.txt文件，因为第二个参数传的a，所以会在原有内容上追加新内容
file.write('hello')
file.close()
#复制图片
src_file=open('logo.png','rb')
target_file=open('copylogo.png','wb')
target_file.write(src_file.read())# 边读边写
target_file.close()
src_file.close()

文件对象的常用方法

#读
file=open('a.txt','r')
print(file.read(5))  #读取size个字节或字符
print(file.readline())  #读取一行内容，输出：中国
print(file.readlines())  #把文本文件中的每一行都作为独立的字符对象，并将这些对象放入列表返回。输出：['中国\n','美丽']
#写
file=open('c.txt','a')
# file.write('hello')
lst=['java','go','python']
file.writelines(lst)# hellojavagopython
file.close()
#移动文件指针
file=open('c.txt','r')
file.seek(2)  #将文件移动到新的位置，一个汉字占2字节，这里写1会报错，写2会从国开始输出
print(file.read())
'''
国
美丽
''' 
print(file.tell())  #返回指针当前所处位置。如果文件写完了，file.tell()返回文件长度
file.close()

file=open('d.txt','a')
file.write('hello')
file.flush()  #把缓冲区的内容写入文件，但不关闭文件
file.write('world')
file.close()

with语句

#with语句(上下文管理器)
with open('a.txt','r') as file:# 打开a.txt文件，为打开的这个文件起别名：file，file就是上下文管理器
    print(file.read())
#不用手动关闭!

将open('a.txt','r')称为上下文表达式，他的执行结果file是一个上下文管理器

上下文管理器：一个类对象实现了__enter__()、__exit__()，那么该类对象遵守上下文管理协议，该类的实例对象就称为上下文管理器

上述MyContentMgr类就是遵守上下文管理协议，他的实例对象MyContentMgr()就被称为上下文管理器

先执行__enter__()方法，再执行with语句体，然后退出上下文管理器，执行__exit__()方法。如果在执行with语句体的时候出现了异常，也会调用__exit__()方法，说明在上下文管理器中，无论是否有异常都会调用__enter__()、__exit__()方法

利用with语句实现前述图片的复制：

with open('logo.png','rb') as src_file
	with open('copylogo.png','wb') as target_file
		target_file.write(src_file.read())# 边读边写

os模块的常用函数

#os模块与操作系统相关的一个模块
import os
os.system('notepad.exe')# 打开系统中的记事本（应用程序）
os.system('calc.exe')# 打开系统中的计算器（应用程序）
#直接调用可执行文件
os.startfile('C:\\Program Files (x86)\\Tencent\\QQ\\Bin\\QQ.exe')

import os
print(os.getcwd())  #返回当前的工作目录（绝对路径）
lst=os.listdir('python')  #返回指定路径下的文件和目录信息，这里参数要写相对路径
print(lst)
os.makedirs('TXT/1.txt')  #创建多级目录
os.mkdir('TXT/0.txt')  #创建目录
os.rmdir('TXT')  #删除目录
os.removedirs('TXT/1.txt')  #删除多级目录
os.chdir('C:\\')  #改变工作路径
print(os.getcwd())

path模块的常用方法

#os.path模块
import os.path
print(os.path.abspath('1.py'))  #获取文件的绝对路径
print(os.path.exists('1.py'),os.path.exists('2.py'))  #判断文件是否存在T/F
print(os.path.join('C:\\download','1.py'))  #目录和文件拼接操作，输出：C:\\download\\1.py
print(os.path.split('C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python\\helloworld.py'))  #拆分路径和文件，输出：('C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python','helloworld.py')
print(os.path.splitext('helloworld.py'))  #拆分文件和后缀名，输出：('helloworld','.py')
print(os.path.basename('C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python\\helloworld.py'))  #提取文件名，输出：helloworld.py
print(os.path.dirname('C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python\\helloworld.py'))  #提取目录名，输出：C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python
print(os.path.isdir('C:\\Users\\26066\\Desktop\\program\\VScode\\.vscode\\python'))  #判断是否是路径（目录）

#获取当前目录下的.txt文件
import os
path=os.getcwd()# 获取当前目录
lst=os.listdir(path)# 获取路径下的所有文件
for filename in lst:
    if filename.endswith('.txt'):# 如果文件名以.txt结尾
        print(filename)

#
import os
path=os.getcwd()
lst_files=os.walk(path)  #遍历目录下的所有文件夹及其子文件
for dirpath,dirname,filename in lst_files:
    # print(dirpath)# 当前路径
    # print(dirname)# 文件夹
    # print(filename)# 文件
    for dir in dirname:
        print(os.path.join(dirpath,dir))
    for file in filename:
        print(os.path.join(dirpath,file))