Python

第一章：出使python国

python的自述

搭建python开发环境

python中的输出函数

print()函数

print()函数的使用

# 可以输出数字
print(520)
print(98.5)


# 可以输出字符串
print("helloworld")
print('helloworld')

#含有运算符的表达式
print(2+4)
# 输出在文件当中  注意：1.所指定的盘符存在 2.使用file = fp
fp=open('D:/text.txt',"a+") # a+ :如果文件不存在就创建，存在就在文件内容的后面继续追加
print('helloworld',file = fp)
fp.close()

#不进行换行输出
print("hello","world","python")

转义字符与原字符

# 转义字符
print("hello\nworld") #\+转义功能的首字母  n-->newline的首字符表示换行
print("hello\tworld") # 3个空格  一个\t占4个单元格
print("helloooo\tworld") # 4个空格

print("hello\rworld") #world  world把hello覆盖掉了
print("hello\bworld")  #hellworld  \b时退一个格，把o退没了

print("http:\\\\www.baidu.com")  #反斜杠 \\

print("老师说：\"大家好\"") #双引号 \"

#原字符：不希望字符中的转义字符起作用，就使用原字符，就是在字符串之前加上r，或R
print(r'hello\nworld')
#注意事项 最后一个字符不能是反斜杠，可以是多个反斜杠
# print(r'hello\nworld\')
print(r'hello\nworld\\')

第二章：七十二变

二进制与字符编码

• 1B=8b
• 1KB =1024B
• 1MB=1024KB
• 1GB=1024MB
• 1TB=1024GB

计算机为什么能够认识我？

print(chr(0b100111001011000)) #乘
print(ord("乘"))  #20056

Python中的标识符与保留字

• 保留字
  有些单词被赋予了特定的意义，这些单词在给任何对象起名字的时候不能用

import keyword
print(keyword.kwlist)
#['False', 'None', 'True', 'and', 'as', 
#'assert', 'async', 'await', 'break', 'class', 
#'continue', 'def', 'del', 'elif', 'else', 
#'except', 'finally', 'for', 'from', 'global', 
#'if', 'import', 'in', 'is', 'lambda', 
#'nonlocal', 'not', 'or', 'pass', 'raise', 
#'return', 'try', 'while', 'with', 'yield']

• 规则
  变量、函数、类、模块和其他对象的起的名字就叫标识符
  规则：
  1. 字母、数字、下划线…
  2. 不能以数字开头
  3. 不能是保留字
  4. 严格区分大小写

Python中的变量与数据类型

• 变量是内存中一个带标签的盒子，把所需要的数据放进去
  

name = 'maliya'
print(name)
# maliya

• 变量由三部分组成

1. 标识：表示对象所存储的内存地址，使用内置函数id(obj)来获取
2. 类型：表示的是对象的数据类型，使用内置函数type(obj)来获取
3. 值：表示对象所存储的具体数据，使用print(obj)可以将值进行打印
   内存分析图：
   

print('标识',id(name))
print('类型',type(name))
print('值',name)
#标识 1678643624816
#类型 <class 'str'>
#值 maliya

• 变量多次赋值以后，变量名会指向新的空间
  name = '玛丽亚' name = '楚溜冰'

name = '玛丽亚'
name = '楚溜冰'
print(name)
# 楚溜冰

• 常用的数据类型
  

1. 整数类型
   

# 整数表示
# 可以表示：正数、负数、0
n1 = 90
n2 = -76
n3 = 0
print(n1,type(n1)) #90 <class 'int'>
print(n2,type(n2)) #-76 <class 'int'>
print(n3,type(n3)) #0  <class 'int'>
# 正数可以表示为二进制，十进制，八进制，十六进制
print('十进制',118) #118
print('二进制',10101111) #10101111
print('二进制',0b10101111) #175 二进制以0b开头
print('八进制',0o176) #126 八进制以0o开头
print('十六进制',0x1EAF) #7855 十六进制以0x开头

2. 浮点类型
   

a=3.14159
print(a,type(a))
n1=1.1
n2=2.2
print(n1+n2)
from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))

#3.14159 <class 'float'>
#3.3000000000000003
#3.3

3. 布尔类型
   

f1=True
f2=False
print(f1,type(f1))
print(f2,type(f2))

# 布尔值可以转化成整数计算
print(f1+1) #2
print(f2+1) #1
#True <class 'bool'>
#False <class 'bool'>
#2
#1

4. 字符串类型
   

str1 = '人生苦短，我用python'
str2 = "人生苦短，我用python"
str3 = """ 人生苦短，
我用python"""
str4 = ''' 人生苦短，
    我用python
'''
print(str1,type(str1))
print(str2,type(str2))
print(str3,type(str3))
print(str4,type(str4))
#人生苦短，我用python <class 'str'>
#人生苦短，我用python <class 'str'>
 #人生苦短，
#我用python <class 'str'>
 #人生苦短，
  #  我用python
 #<class 'str'>

• 数据类型转换
  

name = '张三'
age = 20
print(type(name),type(age)) #<class 'str'> <class 'int'> 说明name和age的数据类型不同

# print('我叫'+name+'今年'+age+'岁') #当将str类型与int类型进行连接时，报错，解决方案，类型转换
print('我叫' + name + '今年' + str(age) + '岁')
#将int类型通过str()函数转换成了str类型

print('----------str()将其它类型转换成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(str(a)),type(str(b)),type(str(c)))
# 10 198.8 False <class 'str'> <class 'str'> <class 'str'>
print('----------int()将其它类型转换成str类型------------')
s1='128'
f1=98.7
s2="76.77"
ff=True
s3='hello'
print(type(s1),type(f1),type(s2),type(ff),type(s3))
# <class 'str'> <class 'float'> <class 'str'> <class 'bool'> <class 'str'>
print(int(s1),type(int(s1))) # 将str转成int类型，字符串为数字串 128 <class 'int'>
print(int(f1),type(int(f1))) # float转成int类型，截取整数部分，舍掉小数部分  98 <class 'int'>
#print(int(s2),type(int(s2))) # 将str转成int类型，报错，因为字符串为小数串
print(int(ff),type(int(ff))) #1 <class 'int'>
#print(int(s3),type(int(s3))) #报错，将str转成int类型时，字符串必须为数字串（整数），非数字串不允许被转换


print('----------float()函数将其它类型转换成float类型------------')
s1='1298.98'
s2='76'
ff=True
s3='hello'
i=98
print(type(s1),type(s2),type(ff),type(s3),type(i))
#<class 'str'> <class 'str'> <class 'bool'> <class 'str'> <class 'int'>
print(float(s1),type(float(s1)))
#1298.98 <class 'float'>
print(float(s2),type(float(s2)))
#76.0 <class 'float'>
print(float(ff),type(float(ff)))
#1.0 <class 'float'>

#print(float(s3),type(float(s3)))  #报错 字符串中的数据如果是非数字串，则不允许转换
print(float(i),type(float(i)))
# 98.0 <class 'float'>

Python中的注释

#codeing:utf-8
#通过记事本打开，另存为可以看到文件的编码格式
# 输入功能（单行注释）
print('hello')
'''
嘿嘿，
我是
多行注释
'''

第三章：算你赢

Python的输入函数input（）

• 介绍

• 使用
  

# 输入函数input
present=input('大圣想要什么礼物呢？')
print(present)
print(present,type(present))

'''
大圣想要什么礼物呢？金箍棒
金箍棒
金箍棒 <class 'str'>
'''

练习：键盘输入两个整数，求两数之和

a=input('请输入一个加数：')
b=input('请输入另一个加数:')
print(type(a),type(b))
print(a+b) #1 2  12

a=int(a)
b=int(b)

print(type(a),type(b))
print(a+b)
'''
请输入一个加数：12
请输入另一个加数:12
<class 'str'> <class 'str'>
1212
<class 'int'> <class 'int'>
24
'''

Python中的运算符

算术运算符

标准算术运算符、取余运算符、幂运算符

print(1+1)  #加法运算
print(1-1)  #减法运算
print(2*4)  #乘法运算
print(1/2)  #除法运算
print(11//2) #5 整除运算
print(11%2)  #1 取余运算
print(2**2)  #表示的是2的2次方
print(2**3)  #表示的是2的3次方
''''
2
0
8
0.5
5
1
4
8
'''

赋值运算符

# 赋值运算符，运算顺序从右到左

i=3+4
print(i)
a=b=c=20 #链式赋值
print(a,id(a))
print(b,id(b))
print(c,id(c))

print('------------------支持参数赋值---------------------')
a=20
a+=30 #相当于a=a+30
print(a)
a-=10 #相当于a=a-10
print(a)
a*=2  #相当于a=a*2
print(a)  #int
print(type(a))

a/=3  #相当于a=a/3
print(a)
print(type(a))  #float
a//=2
print(a)
print(type(a))  #float
a%=3
print(a)

print('-----------------解包赋值--------------------')
a,b,c=20,30,40
print(a,b,c)

#a,b=20,30,40  报错，因为左右变量的个数和值的个数不对应
print('--------------------交换两个变量的值------------------------')
a,b=10,20
print('交换之前：',a,b)
a,b=b,a
print('交换之后：',a,b)
'''
7
20 140704091719936
20 140704091719936
20 140704091719936
------------------支持参数赋值---------------------
50
40
80
<class 'int'>
26.666666666666668
<class 'float'>
13.0
<class 'float'>
1.0
-----------------解包赋值--------------------
20 30 40
--------------------交换两个变量的值------------------------
交换之前： 10 20
交换之后： 20 10

'''

比较运算符

# 比较运算符，比较运算符的结果为bool类型
a,b = 10,20
print('a>b吗？',a>b)  #false
print('a<b吗？',a<b)  #true
print('a>=b吗？',a>=b) #false
print('a<=b吗？',a<=b) #true
print('a==b吗？',a==b) #false
print('a!=b吗？',a!=b) #true

'''
一个=为赋值运算符，==为比较运算符
一个变量由三部分组成，标识、类型、值
== 比较的是值还是标识？ 比较的是值
比较对象的标识使用is
'''
a = 10
b = 10
print(a==b) #true 说明a与b的值相等
print(a is b) #true 说明a与b的id标识，相等

list1=[11,22,33,44]
list2=[11,22,33,44]
print(list1==list2) # value  true
print(list1 is list2) #id   false
print(id(list1)) #2069998488960
print(id(list2)) #2069999546880
print(a is not b)#false
print(list1 is not list2) #false

布尔运算符

print('-------------not 对bool类型操作数取反-------------------')
f=True
f2 = False
print(not f) #False
print(not f2) #True
print('------------in与not in ---------------')
s = 'helloworld'
print('w' in s) #True
print('k' in s) #False
print('w' not in s) #False
print('k' not in s) #True

位运算符

运算符的优先级

程序的组织结构

顺序结构

略。

选择结构

# 测试对象的bool值

print('---------------以下对象的布尔值为False---------------')
print(bool(False))
print(bool(0))
print(bool(0,0))
print(bool(None))
print(bool(''))
print(bool([])) #空列表
print(bool(list())) #空列表
print(bool(())) #空元组
print(bool(tuple())) #空元组
print(bool({})) #空字典
print(bool(dict())) #空字典
print(bool(set())) #空集合
print('---------------其它对象的布尔值均为True--------')
print(bool(18))
print(bool(True))
print(bool('helloworld'))

单分支结构

money = 100
s = int(input("请输入取款金额:"))
#判断金额是否充足
if money>=s:
    money-=s
    print('取款成功，余额为：',money)

双分支结构

num = int(input("请输入一个整数"))
#条件判断
if num%2==0:
    print(num,'是偶数')
else:
    print(num,'是奇数'

多分支结构

'''
多分支结构，多选一执行
'''

score = int(input('请输入一个成绩：'))
#判断
if score>=90 and score<=100:
# 90<=score<=100 在python中可以这样写
    print('A级')
elif score>=80 and score<90:
    print('B级')
elif score>=70 and score<80:
    print('C级')
elif score>=60 and score<70:
    print('D级')
elif score>=0 and score<60:
    print('E级')
else:
    print('对不起，成绩有误，不在成绩的有效范围')

嵌套if

'''
会员  >=200 8折
     >=100 9折
非会员 >=200 9.5折
     不打折
'''

#判断是否是会员
answer = input('您是会员吗？y/n\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('打9.5折，付款金额为：',money*0.95)
    else:
        print('不打折，付款金额为：',money)

条件表达式

num_a = int(input('请输入第一个整数：'))
num_b = int(input('请输入第二个整数：'))
 # 比较大小
'''
if num_a>=num_b:
    print(num_a,'大于等于',num_b)
else:
    print(num_a,'小于',num_b)
'''
print('使用条件表达式进行比较')
print(str(num_b)+'大于等于'+str(num_b) if num_a>=num_b else str(num_a)+'小于'+str(num_b))

pass语句

#pass语句，什么都不做，只是一个占位符，用到需要写语句的地方

answer = input('您是会员吗？y/n')
if answer=='y':
    pass
else:
    pass

循环结构

range()函数的使用

#range()的三种创建方式
'''
第一种创建方式，只有一个参数（小括号中只给了一个数）
'''
r = range(10) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]，默认从0开始，默认相差1称为步长
print(r)#range(0,10)
print(list(r)) #用于查看range对象中的整数序列  ----> list是列表的意思

'''
第二种创建方式，给了两个参数（小括号中给了两个数）
'''
r = range(1,10) #指定了起始值，从1开始，到10结束（不包含10），默认步长为1
print(list(r)) #[1, 2, 3, 4, 5, 6, 7, 8, 9]

'''
第三种创建方式，给了三个参数（小括号中给了三个数）
'''
r = range(1,10,2)
print(list(r)) #[1, 3, 5, 7, 9]

'''
判断指定的整数在序列中是否存在，in，not in
'''
print(10 in r) #False ,10不在当前的r这个整数序列中
print(9 in r) #True,9在当前的r这个序列中

print(10 not in r) #True
print(9 not in r) #False 

while循环

for-in循环

for item in 'Python':  #第一次取出来的是p，将p赋值item，将item的值输出
    print(item)

# range 产生一个整数序列，---->也是一个可迭代对象
for i in range(10):
    print(i)

#如果在循环体中不需要使用到自定义变量，可将自定义变量写为“_”
for _ in range(5):
    print('人生苦短，我用python')
print('使用for循环，计算1到100之间的偶数和')
sum = 0
for item in range(1,101):
    if item%2 == 0:
        sum += item

水仙花数

'''
输出100到999之间的水仙花数
举例：
    153=3*3*3+5*5*5+1*1*1
'''
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与else语句

'''从键盘录入密码，最多录入三次，如果正确就结束循环'''
for item in range(3):
    pwd = input('请输入密码：')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')

'''
要求输出1到50之间所有5的倍数，5，10，15，20...
'''
for item in range(1,51):
    if item%5==0:
       print(item)

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

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

print('-------while-else-------')
a = 0
while a<3:
    pwd = input('请输入密码：')
    if pwd == '8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
    a+=1
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):
        print('*',end='')
        

    print()
'''
99乘法表
'''
for i in range(1,10): #行数
    for j in range(1,i):
        print(i,'*',j,'=',i*j,end='\t')

    print()

二重循环中的break和continue

列表

列表的创建与删除

'''
创建列表的第一种方式，使用[]
'''
lst = ['hello','world',98]
'''
创建列表的第二种方式，使用内置函数list()
'''
lst2 = list(['hello','world',98])

lst = ['hello','world',98]
print(lst)
print(lst[0],lst[-3])

列表的查询操作

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

lst = ['hello','world',98,'hello','world',234]
#获取索引为2的元素
print(lst[2]) # 98
#获取索引为-3的元素
print(lst[-3]) # hello
#获取索引为10的元素
# print(lst[10]) #ValueError: 1 is not in list

lst = [10,20,30,40,50,60,70,80,90]
#start = 1,stop = 6,step = 1
print('原列表:',id(lst)) #原列表: 2694570659328
lst2 = lst[1:6:1]
print('切的片段：',id(lst2)) # 切的片段： 2694571520576
print(lst[1:6]) #默认步长为1 [20, 30, 40, 50, 60]
print(lst[1:6:]) #步长为1 [20, 30, 40, 50, 60]
#start=1,stop=6,step=2
print(lst[1:6:2]) #[20, 40, 60]
#stop=6,step=2,start采用默认
print(lst[:6:2]) #[10, 30, 50]
#start=1,step=2,stop采用默认
print(lst[1::2])
print('---------------step为负数的情况-------------------')
print('原列表：',lst)
print(lst[::-1]) #[90, 80, 70, 60, 50, 40, 30, 20, 10]
#start=7,stop省略 step=-1
print(lst[7::-1]) #[80, 70, 60, 50, 40, 30, 20, 10]
#start=6,stop=0,step=-2
print(lst[6:0:-2]) #[70, 50, 30]

print('p' in 'python') #True
print('k'not in 'python') #True
lst=[10,20,'python','hello']
print(10 in lst) #True
print(10 not in lst) #False
print(100 not in lst) #True
print('-----------------------')
for item in lst:
    print(item)

列表元素的增、删、改操作

#向列表的末尾添加一个元素
lst = [10,20,30]
print('添加元素之前',lst,id(lst)) #添加元素之前 [10, 20, 30] 2998042643968
lst.append(100)
print('添加元素之后',lst,id(lst)) #添加元素之后 [10, 20, 30, 100] 2998042643968

lst2 = ['hello','world']
lst.append(lst2) #将lst2作为一个元素添加到列表的末尾
#向列表的末尾一次性添加多个元素
lst.extend(lst2)
# [10, 90, 20, 30, 100, ['hello', 'world'], 'hello', 'world']
#在任意位置上添加一个元素
lst.insert(1,90)
print(lst)

lst3=[True,False,'hello']
#在任意的位置上添加N多个元素
lst[1:] = lst3
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]

#pop()根据索引移除元素
lst.pop(1)
print(lst) #[10, 40, 50, 60, 30]
#lst.pop(5)  #IndexError: pop index out of range 如果指定的索引位置不存在，将抛出异常

lst.pop() #如果不指定参数索引，删除列表中最后一个元素
print(lst)

print('------------切片操作删除至少一个元素，将产生一个新的列表对象------------------')
new_list = lst[1:3]
print('原列表：',lst) #原列表： [10, 40, 50, 60]
print('切片后的列表',new_list) #切片后的列表 [40, 50]
''' 不产生新的列表对象，而是删除原列表中的内容'''
lst[1:3] = []
print(lst) #[10, 60]

'''清除列表中的所有元素'''
lst.clear()
print(lst)  #[]

'''del语句将列表对象删除'''
del lst

lst = [10,20,30,40]
#一次修改一个值
lst[2] = 100
print(lst)  #[10, 20, 100, 40]

lst[1:3] = [300,400,500,600]
print(lst)  #[10, 300, 400, 500, 600, 40]

列表元素的排列

sorted()是新建了一个列表，原列表不发生改变，sort()是将列表进行排序

lst = [20,40,10,98,54]
print('排序前的列表',lst,id(lst))  #排序前的列表 [20, 40, 10, 98, 54] 1985748225536

#开始排序，调用列表对象的sort方法，升序排列
lst.sort()
print('排列后的列表',lst,id(lst))  #排列后的列表 [10, 20, 40, 54, 98] 1985748225536

#通过指定关键字参数，将列表中的元素进行降序排序
lst.sort(reverse = True) #reverse=True 表示降序排序，reverse=False就是升序排序
print(lst) #[98, 54, 40, 20, 10]
lst.sort(reverse=False)
print(lst) #[10, 20, 40, 54, 98]


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

列表推导式

lst = [i*i for i in range(1,10)]
print(lst)
'''列表中的元素的值为2，4，6，8，10'''
lst2 = [i*2 for i in range(1,6)]
print(lst2)

字典

什么是字典、字典的原理

key通常为不可变序列
通常的可变序列：列表、字典

字典的创建与删除

'''字典的创建方式'''

'''使用{}创建字典'''
scores={'张三':100,'李四':98,'王五':45} #{'张三': 100, '李四': 98, '王五': 45}
print(scores)
print(type(scores))#<class 'dict'>

'''第二种创建dict()'''
student=dict(name='jack',age=20)
print(student) #{'name': 'jack', 'age': 20}

'''空字典'''
d={}
print(d) #{}

字典的查询操作

# 获取字典的元素
scores = {'张三':100,'李四':98,'王五':45}
'''第一种方式，使用[]'''
print(scores['张三'])
# print(scores['chen'])  #KeyError: 'chen'

'''第二种方式，使用get()方法'''
print(scores.get('张三'))
print(scores.get('chen'))  #None
print(scores.get('马奇',99)) #99是在查找’马奇‘不存在时返回的一个默认值

字典元素的增、删、改操作

'''key的判断'''
scores = {'张三':100,'李四':98,'王五':45}
print('张三' in scores)
print('张三' not in scores)

del scores['张三'] #删除指定的ley-value键值对
# scores.clear() #请空字典的元素
print(scores)

scores['陈六']=98
print(scores)

scores['陈六'] = 100 #修改元素
print(scores)

获取字典试图

scores = {'张三':100,'李四':98,'王五':45}
#获取所有得key
keys = scores.keys()
print(keys)         #dict_keys(['张三', '李四', '王五'])
print(type(keys))   #<class 'dict_keys'>
print(list(keys)) #将所有的key组成的视图转成列表 #['张三', '李四', '王五']

#获取所有得value
values= scores.values()
print(values)           #dict_values([100, 98, 45])
print(type(values))     #<class '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)]

字典元素的遍历

scores = {'张三':100,'李四':98,'王五':45}
for item in scores:
    print(item,scores[item],scores.get(item))
    '''
    张三 100 100
    李四 98 98
    王五 45 45

    '''

字典的特点

d = {'name':'张三','name':'李四'}   #key不允许重复
print(d)#{'name': '李四'}

d={'name':'张三','nickname':'张三'} #value可以重复的
print(d)  #{'name': '张三', 'nickname': '张三'}

lst=[10,20,30]
lst.insert(1,100)
print(lst)
'''
d={lst:100}
print(d)  #TypeError: unhashable type: 'list'
key必须是不可变对象，如整数类型。列表和字典是可变的
'''

字典推导式

items = ['Fruits','Books','Others']
prices=[96,78,85]

d={
    item.upper():price for item,price in zip(items,prices)
}
print(d)  #{'FRUITS': 96, 'BOOKS': 78, 'OTHERS': 85}

'''
以元素少的那个生成
'''
price2 = [96,78,85,100,120]
d={
    item.upper():price for item,price in zip(items,price2)
}
print(d)  #{'FRUITS': 96, 'BOOKS': 78, 'OTHERS': 85}

元组、集合

什么是元组

'''
可变序列 列表、字典
'''
lst=[10,20,45]
print(id(lst)) #2531190525888
lst.append(300)
print(id(lst)) #2531190525888

'''
不可变序列，字符串、元组
'''
s='hello'
print(id(s)) #2531190525296
s=s+'world'
print(id(s)) #2531190731120

元组的创建方式

'''元组的创建方式'''
'''第一种，使用（）'''
t = ('python','world',98)
print(t) #('python', 'world', 98)
print(type(t)) #<class 'tuple'>

t2 = 'python','world',98
print(t2) #('python', 'world', 98)
print(type(t2)) #<class 'tuple'>

t3 = ('python') #如果元组中只有一个元素，逗号不能省
print(t3) #python
print(type(t3)) #<class 'str'>

t4 = ('python',)
print(t4) #('python',)
print(type(t4)) #<class 'tuple'>

'''第二种创建方式，使用内置函数tuple()'''
t1=tuple(('python','world',98))
print(t1) #('python', 'world', 98)
print(type(t1)) #<class 'tuple'>

'''空元组的创建方式'''
'''空列表的创建方式'''
lst = []
lst1 = list()

d = {}
d2 = dict()

#空元组
t4=()
t5=tuple()

print('空列表',lst,lst1)
print('空字典',d,d2)
print('空元组',t4,t5)
'''
空列表 [] []
空字典 {} {}
空元组 () ()
'''

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

t = (10,[20,30],9)
print(t)
print(type(t))
print(t[0],type(t[0]),id(t[0]))
print(t[1],type(t[1]),id(t[1]))
print(t[2],type(t[2]),id(t[2]))
'''
(10, [20, 30], 9)
<class 'tuple'>
10 <class 'int'> 140734481294408
[20, 30] <class 'list'> 2795610787776
9 <class 'int'> 140734481294376
'''
'''尝试将t[1]修改成100'''
print(id(100))
#t[1]=100 #错误。元组是不允许修改元素的
'''
由于[20,30]列表，而列表是可变序列，所以可以向列中添加元素，而列表的内存地址不变
'''
t[1].append(100) #向列表中添加元素
print(t,id(t[1])) #(10, [20, 30, 100], 9) 2056378011584

元组的遍历

t=('python','world',98)
'''第一种获取元组元素的方式，使用索引'''
print(t[0])
print(t[1])
print(t[2])
'''遍历元组'''
for item in t:
    print(item)
    '''
    python
    world
    98
    python
    world
    98
    '''

什么是集合

集合的创建

#集合的创建方式
'''第一种创建方式使用[]'''
s = {1,2,3,4,5,6,7,7} #集合中的元素不允许重复
print(s) #{1, 2, 3, 4, 5, 6, 7}

'''第二种创建方式使用set()'''
s1 = set(range(6))
print(s1,type(s1)) #{0, 1, 2, 3, 4, 5} <class 'set'>

s2=set([1,2,4,5,5,5,6,6])
print(s2,type(s2)) #{1, 2, 4, 5, 6} <class 'set'>

s3=set((1,2,4,4,5,65)) #集合中的元素是无序的
print(s3,type(s3)) #{65, 1, 2, 4, 5} <class 'set'>

s4 = set('python')
print(s4,type(s4)) #{'n', 'o', 'y', 'p', 't', 'h'} <class 'set'>

s5 = set({12,3,23,44,55,66,41})
print(s5,type(s5)) #{66, 3, 23, 55, 41, 12, 44} <class 'set'>

#定义一个空集合
s6={}  #dict字典类型
print(type(s6)) #<class 'dict'>

s7=set()
print(type(s7)) #<class 'set'>

集合的增、删、改、查操作

# 集合的相关操作

s = {10,20,30,40,50,60}
#集合元素的判断操作
print(10 in s) #True
print(100 in s) #False
print(10 not in s) #False
print(100 not in s) #True
#集合元素的新增操作
s.add(80)   #add一次添加一个元素
print(s)  #{80, 50, 20, 40, 10, 60, 30}
s.update({200,400,300}) #一次添加至少一个元素
print(s) #{40, 200, 10, 300, 80, 400, 50, 20, 60, 30}
s.update([100,99,8])
print(s)#{99, 100, 40, 200, 10, 8, 300, 80, 400, 50, 20, 60, 30}
s.update((78,89,92))
print(s)#{99, 100, 40, 200, 10, 8, 300, 78, 92, 80, 400, 50, 20, 89, 60, 30}
#集合元素的删除操作
s.remove(100)
print(s)
#s.remove(500) ##KeyError: 500
#print(s)
s.discard(500) #元素不存在不抛异常
print(s) #{99, 40, 200, 10, 8, 300, 78, 92, 80, 400, 50, 20, 89, 60, 30}
s.pop()#任意删除一个
# s.pop(400) #报错，没有参数不能指定参数。TypeError: set.pop() takes no arguments (1 given)
print(s) #{40, 200, 10, 8, 300, 78, 92, 80, 400, 50, 20, 89, 60, 30}
s.clear()
print(s) #set()

集合间的关系

s={10,20,30,40}
s2={30,40,20,10}
'''两个集合是否相等（元素相同，就相等）'''
print(s==s2) #True
print(s!=s2) #False
'''一个集合是否是另一个集合的子集'''
s1={10,20,30,40,50,60}
s2={10,20,30,40}
s3={10,20,90}
print(s2.issubset(s1)) #True
print(s3.issubset(s1)) #False

'''一个集合是否是另一个集合的超集'''
print(s1.issuperset(s2)) #True
print(s1.issuperset(s3)) #False
'''两个集合是否没有交集'''
print(s2.isdisjoint(s3)) #False 有交集为False
s4={100,200,300,400}
print(s2.isdisjoint(s4)) #True 没有交集为True

集合的数学操作

#集合的数学操作
# 1 交集
s1 = {10,20,30,40}
s2 = {20,30,40,50,60}
print(s1.intersection(s2)) #{40, 20, 30}
print(s1&s2) #{40, 20, 30}  intersection()与&等价，交集操作
print(s1) #{40, 10, 20, 30}
print(s2) #{50, 20, 40, 60, 30} 交集之后的s1、s2没有变化

 # 2 并集
print(s1.union(s2)) #{40, 10, 50, 20, 60, 30}
print(s1|s2) #{40, 10, 50, 20, 60, 30} union()与|等价，并集操作
print(s1) #{40, 10, 20, 30}
print(s2) #{50, 20, 40, 60, 30} 并集之后的s1、s2没有变化

# 3 差集操作
print(s1.difference(s2)) #{10}
print(s1-s2)#{10}
print(s1) #{40, 10, 20, 30}
print(s2) #{50, 20, 40, 60, 30} 差集之后的s1、s2没有变化
# 4 对称差集
print(s1.symmetric_difference(s2)) #{50, 10, 60}
print(s1^s2) #{50, 10, 60}

集合生成式

#列表生成式
lst=[i*i for i in range(6)]
print(lst) #[0, 1, 4, 9, 16, 25]

#集合生成式
s = {i*i for i in range(6)}
print(s) #{0, 1, 4, 9, 16, 25}

列表、字典、元组、集合总结

字符串

字符串的驻留机制

字符串的常用操作

#字符串得查询操作
s='hello,hello'
print(s.index('lo')) #3
print(s.find('lo')) #3
print(s.rindex('lo')) #9
print(s.rfind('lo')) #9

#print(s.index('k')) #ValueError: substring not found
print(s.find('k')) #-1
#print(s.rindex('k'))  #ValueError: substring not found
print(s.rfind('k')) #-1

#字符串中的大小写转换的方法
s='hello,python'
a=s.upper() #转成大写之后，会产生一个新的字符串对象
print(a,id(a)) #HELLO,PYTHON 2119036793584
print(s,id(s)) #hello,python 2119035473392
#转换之后，会产生一个新的字符串对象
b=s.lower()
print(b,id(b)) #hello,python 2011437560432
print(s,id(s)) #hello,python 2011436436976
print(b==s) #True
print(b is s) #False

s2='hello,Python'
print(s2.swapcase()) #HELLO,pYTHON
print(s2.capitalize()) #Hello,python
print(s2.title()) #Hello,Python

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('-1980'.zfill(8))  #-0001980

s='hello world Python'
lst=s.split()
print(lst)#['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('---------------------------')
'''rsplit()从右侧开始劈分'''
print(s.rsplit()) #['hello', 'world', 'Python']
print(s1.rsplit('|')) #['hello', 'world', 'Python']
print(s1.rsplit(sep='|',maxsplit=1)) #['hello|world', 'Python']

s='hello,python'
print('1.',s.isidentifier()) #False
print('2.','hello'.isidentifier()) #True
print('3.','张三_'.isidentifier())#True
print('4.','张三_123'.isidentifier())#True

print('5.','\t'.isspace()) #True
print('6.','abc'.isalpha()) #True
print('7.','张三'.isalpha())#True
print('8','张三123'.isalpha())#False

print('9.','123'.isdecimal())#True
print('10.','123四'.isdecimal())#False
print('11.','ⅠⅡⅢ'.isdecimal())#False

print('12.','123'.isnumeric())#True
print('13.','123四'.isnumeric())#True
print('14.','ⅡⅢ'.isnumeric())#True

print('15.','abc1'.isalnum())#True
print('16.','张三123'.isalnum())#True
print('17.','abc!'.isalnum())#False

s='hello,Python'
print(s.replace('Python','Java')) #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') #True
print('apple'>'banana') #False
print(ord('a'),ord('b'))#97 98

print(chr(97),chr(98)) #a b
print(chr(26472))#杨

'''==与is的区别
==比较的是value
is比较的是id是否相等
'''
a=b='Python'
c='Python'
print(a==b) #True
print(b==c) #Ture
print(a is b) #True
print(a is c)#True
print(id(a))#140733788096504
print(id(b))#140733788096504
print(id(c))#140733788096504

字符串的切片操作

s='hello,python'
s1=s[:5] #由于没有指定起始位置，所以从0开始
s2=s[6:] #由于没有指定结束位置，所以切到字符串的最后一个位置
s3='!'
newstr=s1+s3+s2
print(s1) #hello
print(s2) #python
print(newstr) #hello！python
print('-------------------')
print(id(s))
print(id(s1))
print(id(s2))
print(id(s3))
print(id(newstr))

print('---------切片[start:end:step]----------')
print(s[1:5:1])  #从1开始截到5（不包含5），步长为1  ello
print(s[::2])#默认从0开始，没有写结束，默认到字符串的最后一个元素，步长为2，两个元素之间的索引间隔为2 hlopto
print(s[::-1]) #nohtyp,olleh 默认从字符串的最后一个元素开始，到字符串的第一个元素结束，因为步长为负数
print(s[-6::1]) #从索引为-6开始，到字符串的最后一个元素结束，步长为1

格式化字符串

#格式化字符串
# （1）% 占位符
name='张三'
age=20
print('我叫%s，今年%d岁'%(name,age))

# (2) {}作占位符
print('我叫{0},今年{1}岁'.format(name,age))

# (3) f-string
print(f'我叫{name},今年{age}岁')
'''
我叫张三，今年20岁
我叫张三,今年20岁
我叫张三,今年20岁
'''

print('%10d'%99) #10表示的是宽度
print('hellohello')
print('%.3f'%3.1415926) #.3表示的是小数点后三位
#同时表示宽度和精度
print('%10.3f'%3.1415926) #一共总宽度为10，小数点后三位

print('{0:.3}'.format(3.1415926)) #.3表示的是一共是3位数
print('{0:.3f}'.format(3.1415926)) #.3f表示是3位小数
print('{0:10.3f}'.format(3.1415926)) #.同时设置宽度和精度，一共是10位，3位是小数

字符串的编码转换

s='天涯共此时'
#编码
print(s.encode(encoding='GBK')) #在GBK这种编码格中，一个中文占两个字节
print(s.encode(encoding='UTF-8')) #在UTF-8这种编辑格式中，一个中文占三个字节
'''
b'\xcc\xec\xd1\xc4\xb9\xb2\xb4\xcb\xca\xb1'
b'\xe5\xa4\xa9\xe6\xb6\xaf\xe5\x85\xb1\xe6\xad\xa4\xe6\x97\xb6'
'''

#解码
#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):
    c=a+b
    return c

result=calc(10,20)
print(result) #30

函数的参数传递

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

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

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

• 函数调用的参数传递内存分析图
  

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)

fun(n1,n2) #位置传参，arg1、arg2，是函数定义处的形参，n1、n2是函数调用处的实参，总结：实参名称与形参名称可以不一致
print(n1)
print(n2)
'''
n1= 11
n2= [22, 33, 44]
arg1= 11
arg2= [22, 33, 44]
arg1= 100
arg2= [22, 33, 44, 10]
11
[22, 33, 44, 10]
'''
'''
在函数调用过程中，进行参数的传递
如果是不可变对象，在函数体的修改不会影响实参的值 arg1的修改为100，不会影响n1的值
如果是可变对象，在函数体的修改会影响到实参的值 arg2的修改，append（10），会影响到n2的值
'''

函数的返回值

print(bool(0)) #False
print(bool(8)) #非0的布尔值为True

def fun(num):
    odd=[] #存奇数
    even=[] #存偶数
    for i in num:
        if i%2:
            odd.append(i)
        else:
            even.append(i)
    return odd,even

#函数的调用
lst = [10,29,34,23,44,53,55]
print(fun(lst))   #([29, 23, 53, 55], [10, 34, 44])
'''
函数的返回值
（1）如果函数没有返回值【函数执行完毕之后，不需要给调用处提供数据】 return可以省略不写
（2）函数的返回值，如果是1个，直接返回类型
（3）函数的返回值，如果是多个，返回的结果为元组
'''

def fun1():
    print('hello')
fun1()    #hello
def fun2():
    return 'hello'
res=fun2()
print(res)  #hello

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

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

函数的参数定义

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

#函数的调用
fun(100)

fun(20,30)

print('hello',end='\t')#默认是\n换行
print('world') #hello	world

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

fun(10)
fun(10,30)
fun(30,405,50)
'''
(10,)
10
(10, 30)
10
(30, 405, 50)
30
'''

def fun1(**args):
    print(args)
fun1(a=10)
fun1(a=20,b=30,c=40)
'''
{'a': 10}
{'a': 20, 'b': 30, 'c': 40}
'''
print('hello','world','java') #hello world java
'''
def fun2(*args,*a):
    pass
    以上代码，程序会报错，个数可变的位置参数只能是1个
def fun2(**args,**args):
    pass
    以上代码，程序会报错，个数可变的关键字参数只能是1个
'''
def fun2(*args1,**args2):
    pass
'''def fun3(**args1,*arg2):
    pass
    在一个函数的定义过程中，既有个数可变的关键字形参，也有个数可变的位置形参，要求，个数可变的位置形参，放在个数可变的关键字形参之前
'''

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

#函数的调用
fun(10,20,30) #函数调用时的参数传递，称为位置传参
lst=[11,22,33]
fun(*lst) #在函数调用时，将列表中的每个元素都转换为位置实参传入
print('------------------')
fun(a=100,c=300,b=200) #函数的调用，所以是关键字实参
dic={'a':111,'b':222,'c':333}
fun(**dic)  #在函数调用时，将字典中的键值对都转换为关键字实参传入

def fun(a,b=10): #b是在函数的定义处，所以b是形参，而且进行了赋值，所以b称为默认值形参
    print('a=',a)
    print('b=',b)
def fun2(*args): #个数可变的位置形参
    print(args)
def fun3(**args2): #个数可变的关键字形参
    print(args2)

fun2(10,20,30,40)
fun3(a=11,b=22,c=33,d=44,e=55)

def fun4(a,b,*,c,d): #从*之后的参数，在函数调用时，只能采用关键字参数传递
    print('a=',a)
    print('b=',b)
    print('c=',c)
    print('d=',d)
#调用fun4函数
#fun4(10,20,30,40) #位置实参传递
fun4(a=10,b=20,c=30,d=40) #关键字实参传递
fun4(10,20,c=30,d=40)#前两个参数，采用的是位置实参传递，而c，d采用的是关键字实参传递
'''
需求，c，d只能采用关键字实参传递
'''

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

变量的作用域

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

#print(c)
#print(a)  报错 因为a，c超出了起作用的范围（超出了作用域）

name='杨老师'
print(name)
def fun2():
    print(name)
#调用函数
fun2()

def fun3():
    global age  #函数内部定义的变量，局部变量，局部变量使用global声明，这个变量实际上就变成了全局变量
    age=20
    print(age)
fun3()
print(age)

递归函数

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))  #8
print('--------------------------')
#输出这个数列得前6位上的数字
for i in range(1,7):
    print(fib(i))   # 1 1 2 3 5 8

Bug

Bug的由来及分类

append方法是lst的方法，且每次只可以添加一个

lst=[{'rating':[9.7,50], 'id' :'1292052', ' type':['犯罪','剧情'],'title':'肖中克的救赎','actors':['蒂姆.罗宾斯','摩根.弗里曼']},
{'rating':[9.6,50], 'id':'1291546' , 'type':['剧情','爱情','同性'], 'title':'霸王别姬','actors':['张国荣','张丰毅','巩俐','葛优']},
{'rating': [9.6,50],'id':'1296141' , 'type':['剧情','犯罪','悬疑'], 'title':'控方证人','actors':['泰隆.鲍华','玛琳.黛德丽']}
                                                                                                                        ]

name = input('请输入你要查询的演员：')
for item in lst:  #遍历列表---->{}  item是一个又一个的字典
    act_lst=item['actors']
   # print(act_lst)
    for actor in act_lst:
        if name in actor:
            print(name,'出演了',item['title'])
    '''for movie in item:  #遍历字典，得到movie是一个字典中的key
        print(movie)
        actors = movie['actors']
        if name in item:
            print(name+'出演了'+movie)
   
    print('------------------------')

'''

try:
    a = int(input('请输入第一个整数：'))
    b = int(input('请输入第二个整数：'))
    result = a/b
    print('结果为：',result)
except ZeroDivisionError:
    print('除数不能为0哦！！！')
except ValueError:
    print('只能输入数字串')
print('程序结束')

'''
请输入第一个整数：10
请输入第二个整数：0
除数不能为0哦！！！
程序结束

请输入第一个整数：12
请输入第二个整数：q
只能输入数字串
程序结束
'''

try:
    a = int(input('请输入第一个整数：'))
    b = int(input('请输入第二个整数：'))
    result = a/b
except BaseException as e:
    print('出错了',e)
else:
    print('计算结果为：',result)

try:
    a = int(input('请输入第一个整数：'))
    b = int(input('请输入第二个整数：'))
    result = a/b
except BaseException as e:
    print('出错了',e)
else:
    print('计算结果为：',result)
finally:
    print('谢谢您的使用')

Python当中常见的异常类型

#（1）数学运算异常
#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

异常处理机制

#print(10/0)
import traceback
try:
    print('--------------')
    print(1/0)
except:
    traceback.print_exc()

PyCharm的调试模式

编程思想、对象、方法

两大编程思想

类和对象的创建

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():
        print('我使用了staticmethod进行修饰，所以我是静态方法')
    #类方法
    @classmethod
    def cm(cls):
        print('我是类方法，因为我使用了classmethod进行修饰')
#在类之外定义的称为函数，在类之内定义的称为方法
def drink():
    print('喝水')
    

#创建Student类的对象
stu1=Student('张三',20)
stu1.eat()
print(stu1.name)
print(stu1.age)

print('-------------')
Student.eat(stu1)  #29行与24行代码功能相同，都是调用Student中的eat方法
                   #类名.方法名（类的对象）-->实际上就是方法定义处的self

类属性、类方法与静态方法

#类属性的使用方式
print(Student.native_pace)
stu1 = Student('张三',20)
stu2 = Student('李四',30)
print(stu1.native_pace)
print(stu2.native_pace)
Student.native_pace='天津'
print(stu1.native_pace)
print(stu2.native_pace)
print('---------类方法的使用方式-----------')
Student.cm()
print('---------静态方法的使用方式----------')
Student.method()

动态绑定属性和方法

class Student:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def eat(self):
        print(self.name+'在吃饭')

stu1=Student('张三',20)
stu2=Student('李四',30)
print(id(stu1))
print(id(stu2))
print('----------为stu2动态绑定性别属性-------------')
stu1.gender = '女'
print(stu1.name,stu1.age,stu1.gender)
print(stu2.name,stu2.age)
print('---------------------')
stu1.eat()
stu2.eat()
def show():
    print('定义在类之外的，称函数')
stu1.show=show
stu1.show()

#stu2.show()  因为stu2并没有绑定show方法

面向对象三大特征

封装

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)
print(dir(stu))
print(stu._Student__age)  #在类的外部可以通过_Student_age进行访问```

## 继承
![在这里插入图片描述](https://img-blog.csdnimg.cn/88cdb4419dce4ad396e6e787524b11e9.png)
==提高代码复用性==
![在这里插入图片描述](https://img-blog.csdnimg.cn/5201232b5adf406c8c7ed0def2516cc5.png)

```python
class Person(object): #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,stu_no):
        super().__init__(name,age)
        self.stu_no=stu_no
class Teacher(Person):
    def __init__(self,name,age,teachofyear):
        super().__init__(name,age)
        self.teachofyear=teachofyear

stu=Student('张三',20,'1001')
teacher=Teacher('李四',34,10)
stu.info()
teacher.info()

class A(object):
    pass
class B(object):
    pass
#多继承
class C(A,B):
    pass

方法重写

class Person(object): #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,stu_no):
        super().__init__(name,age)
        self.stu_no=stu_no
    def info(self):
        super().info()
        print(self.stu_no)
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('张三',20,'1001')
teacher=Teacher('李四',34,10)
stu.info()
teacher.info()

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('张三',20)
print(dir(stu))
print(stu)
print(type(stu))
'''
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', 
'__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', 
'__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__',
 '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']
'''

多态

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())
print('---------------------')
fun(Person())

特殊方法和特殊属性

#print(dir(object))
class A:
    pass
class B:
    pass
class C(A,B):
    def __init__(self,name,age):
        self.name=name
        self.age=age
#创建C类的对象
x = C('Jack',20)  #x是C类型的一个实例对象
print(x.__dict__)  #实例对象的属性字典
print(C.__dict__)
print('-----------------')
print(x.__class__) #<class '__main__.C'> 输出了对象所属的类
print(C.__bases__) #(<class '__main__.A'>, <class '__main__.B'>)  C类的父类类型的元素
print(C.__base__)  #<class '__main__.A'>  A 的基类，谁写在前面就会输出谁
print(C.__mro__)  #(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)  类的层次结构
print(A.__subclasses__())  #[<class '__main__.C'>]  A的子类的列表

a=20
b=100
c=a+b  #两个整数类型的对象的相加操作
d=a.__add__(b)

print(c)
print(d)

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  #实现了两个对象的加法运算（因为在Student类中 编写__add__()特殊的方法）
print(s)
s=stu1.__add__(stu2)
print(s)
print('---------------------------------')
lst=[11,22,33,44]
print(len(lst))  #len是内容函数len
print(lst.__len__())
print(len(stu1))

class Person(object):
    def __init__(self,name,age):
        print('__init__被调用了，self的id值为，{0}'.format(id(self)))
        self.name=name
        self.age=age
    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
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为：140713924988400
Person这个类对象的id为：2317444529376
__new__被调用执行了，cls的id值为2317444529376
创建的对象的id为：2317447102160
__init__被调用了，self的id值为，2317447102160
p1这个Person类的实例对象的id：2317447102160
'''

类的深拷贝和浅拷贝

变量的赋值操作

只是形成两个变量，实际上还是指向同一个对象

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,id(cpu1))
print(cpu2,id(cpu2))
'''
<__main__.CPU object at 0x0000014324E08210> 1387893129744
<__main__.CPU object at 0x0000014324E08210> 1387893129744
'''

浅拷贝

python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，因此，源对象与拷贝对象会引用同一个子对象

#浅拷贝
import copy
print(disk)
computer2=copy.copy(computer)
print(computer,computer.cpu,computer.disk)
print(computer2,computer2.cpu,computer2.disk)

深拷贝

使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同

#深拷贝
computer3=copy.deepcopy(computer)
print(computer,computer.cpu,computer.disk)
print(computer3,computer3.cpu,computer3.disk)
'''
<__main__.Computer object at 0x000002336D160410> <__main__.CPU object at 0x000002336D1603D0> <__main__.Disk object at 0x000002336D160450>
<__main__.Computer object at 0x000002336D011CD0> <__main__.CPU object at 0x000002336D1605D0> <__main__.Disk object at 0x000002336D161390>
'''

模块

什么叫模块

自定义模块

import  math #关于数学运算
print(id(math))
print(type(math))
print(math)
print(math.pi)
print('-------------------')
print(dir(math))
print(math.pow(2,3),type(math.pow(2,3)))
print(math.ceil(9.001))
print(math.floor(9.9999))
'''
1567705031648
<class 'module'>
<module 'math' (built-in)>
3.141592653589793
-------------------
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'exp2', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
8.0 <class 'float'>
10
9
'''

以主程序的形式执行

python中的包

第三方模块的安装及使用

import sys
import time
import urllib.request
import math
print(sys.getsizeof(24))
print(sys.getsizeof(45))
print(sys.getsizeof(45))
print(sys.getsizeof(True))
print(sys.getsizeof(False))
print('---------------------')
print(time.time())
print(time.localtime(time.time()))
print('---------------------')
print(urllib.request.urlopen('http://www.baidu.com').read())
print(math.pi)

文件

编码格式介绍

#encoding=gbk对应的文档编码格式是ANSI

文件的读写原理

file=open('a.txt','r')
print(file.readlines())
file.close()

常用的文件打开模式

src_file = open('picture.JPG','rb')
target_file = open('copylogo.png','wb')
target_file.write(src_file.read())
target_file.close()
src_file.close()

文件对象常用的方法

with语句（上下文管理器）

with open('a.txt','r') as file:
    print(file.read())

'''
MyContentMgr实现了特殊方法__enter__(),__exit__()称为该类对象遵守了上下文管理器协议
该类对象的示例对象就称为上下文管理器
MyContentMgr()

'''
class myContentMgr(object):
    def __enter__(self):
        print('enter方法被调用执行了')
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        print('exit方法被调用执行了')
        return self
    def show(self):
        print('show方法被调用执行了')

with myContentMgr() as file:  #相当于file=myContentMgr
    file.show()

with open('picture.JPG','rb') as src_file:
    with open('copy2logo.JPG','wb') as target_file:
        target_file.write(src_file.read())

目录操作

import os
print(os.getcwd())

lst = os.listdir('../chap10')
print(lst)

#os.mkdir('newdir2')
#os.makedirs('A/B/C')
#os.rmdir('newdir2')
#os.removedirs('A/B/C')
os.chdir()

import os.path
print(os.path.abspath('demo12.py'))
print(os.path.exists('demo12.py'),os.path.exists('demo19.py'))
print(os.path.join('E:\\PythonProject','demo12.py'))
print(os.path.split('E:\\PythonProject\\demo12.py'))
print(os.path.splitext('demo12.py'))
print(os.path.basename('E:\\PythonProject\\chap15\\demo12.py'))
print(os.path.dirname('E:\\PythonProject\\chap15\\demo12.py'))
print(os.path.isdir('E:\\PythonProject\\chap15\\demo12.py'))
'''
True False
E:\PythonProject\demo12.py
('E:\\PythonProject', 'demo12.py')
('demo12', '.py')
demo12.py
E:\PythonProject\chap15
False
'''

# 列出指定目录下的所有py文件
import os
path=os.getcwd() #获取当前工作路径
lst=os.listdir(path)
for filename in lst:
    if filename.endswith('.py'):
        print(filename)

import os
path=os.getcwd()
lst_files=os.walk(path)
print(lst_files) #<generator object _walk at 0x000001C046B14320>  一个迭代器对象
for dirpath,dirname,filename in lst_files:
    print(dirpath)
    print(dirname)
    print(filename)
    print('-----------------')
'''
E:\pythonProject\msb_edu_python\chap15
['newdir']
['a.txt', 'b.txt', 'c.txt', 'copy2logo.JPG', 'copylogo.png', 'd.ext', 'demo1.py', 'demo10.py', 'demo11.py', 
'demo12.py', 'demo13.py', 'demo14.py', 'demo2.py', 'demo3.py', 'demo4.py', 'demo5.py', 'demo6.py', 'demo7.py',
 'demo8.py', 'demo9.py', 'picture.JPG']
-----------------
E:\pythonProject\msb_edu_python\chap15\newdir
['sub']

import os
path=os.getcwd()
lst_files=os.walk(path)
print(lst_files) #<generator object _walk at 0x000001C046B14320>  一个迭代器对象
for dirpath,dirname,filename in lst_files:

    for dir in dirname:
        print(os.path.join(dirpath,dir))
    for file in filename:
        print(os.path.join(dirpath,file))
        print('------------------------------')
'''
E:\pythonProject\msb_edu_python\chap15\newdir
E:\pythonProject\msb_edu_python\chap15\a.txt
------------------------------
E:\pythonProject\msb_edu_python\chap15\b.txt
------------------------------
E:\pythonProject\msb_edu_python\chap15\c.txt
------------------------------
E:\pythonProject\msb_edu_python\chap15\copy2logo.JPG
------------------------------
E:\pythonProject\msb_edu_python\chap15\copylogo.png
------------------------------
E:\pythonProject\msb_edu_python\chap15\d.ext
------------------------------
E:\pythonProject\msb_edu_python\chap15\demo1.py
------------------------------
E:\pythonProject\msb_edu_python\chap15\demo10.py
------------------------------
E:\pythonProject\msb_edu_python\chap15\demo11.py
------------------------------
E:\pythonProject\msb_edu_python\chap15\demo12.py
------------------------------
E:\pythonProject\msb_edu_python\chap15\demo13.py
------------------------------
E:\pythonProject\msb_edu_python\chap15\demo14.py
------------------------------
E:\pythonProject\msb_edu_python\chap15\demo2.py
------------------------------
E:\pythonProject\msb_edu_python\chap15\demo3.py
------------------------------
E:\pythonProject\msb_edu_python\chap15\demo4.py
------------------------------
E:\pythonProject\msb_edu_python\chap15\demo5.py
------------------------------
E:\pythonProject\msb_edu_python\chap15\demo6.py
------------------------------
E:\pythonProject\msb_edu_python\chap15\demo7.py
------------------------------
E:\pythonProject\msb_edu_python\chap15\demo8.py
------------------------------
E:\pythonProject\msb_edu_python\chap15\demo9.py
------------------------------
E:\pythonProject\msb_edu_python\chap15\picture.JPG
------------------------------
E:\pythonProject\msb_edu_python\chap15\newdir\sub
E:\pythonProject\msb_edu_python\chap15\newdir\1.py
------------------------------
E:\pythonProject\msb_edu_python\chap15\newdir\2.py
------------------------------
E:\pythonProject\msb_edu_python\chap15\newdir\sub\sub1.py
------------------------------
'''