Python学习笔记

解题思路

1. 分析问题，明确结果
2. 思考需要的知识
3. 思考切入点
4. 尝试解决一部分
5. 重复1-4步

---

转义字符

\a 响铃（BEL）

\b 退格（BS）将当前位置移动到前一列

\f 换页（FF）将当前位置移动到下一页开头

\n 换行（LF）将当前位置下行开头

\r 回车（CR）将当前位置移动到本行开头

\t 水平制表（HT）（跳到下一个TAB位置）

\v 垂直制表（VT）

\\ 代表一个反斜线字符 “"

\' 代表一个单引号

\'' 代表一个双引号

\0 空字符

\ddd 1到3位八进制所代表的任意字符

\xhh 1到2位十六进制所代表的任意字符

---

Print

Print():

单引号不管啥都可打印

双引号可以引出内容的标点符号

三引号跨行输出具体

/n实现换行:

Print(XXX,/nXXX,/nXXX)

---

变量&赋值

赋值

例：

name='小埋'
print(name)
输出：小埋

变量

例：

name='小埋'
name='02'
print(name)
输出：02

变量的命名规范

1. 只能是一个词

2. 只能包含字母

3. 不能以数字开头

4. 尽量描述包含数据的内容

5. 不能使用python函数名或关键字

A = 2  赋值
A == 2 等于

---

数据类型&应用&转换

类型

1. 字符串（string - str）:

   类型有：现实的词，语句，表达式
   必须有引号否则报错
   有引号的是字符串，没有的是整数

2. 整数（integer - int）:

   不带小数点的数字，正负都可

3. 浮点数（float）:

   带小数点的数字，运算结果存在误差

应用

四则运算：符号

XX += 1   #意思是XX =XX+1

字符串拼接：

类型相同 +号拼接

数据类型的查询——type()函数

例：print(type('查询的内容'))

数据转换

Str()函数：将其他数据类型转换成字符串 （也可用引号转换）

例：number = 153，code = '通行密码'
	print(who+destination+code+action+str(number))

Int()函数：将其他数据类型转换成整数 (直接抹零不做四舍五入处理)

例：number1 = '6'     number2 = '1'
       print(int(number1)+int(number2))

浮点形式的字符串 print(int('3.8'))不能转换，
浮点数 print(int(3.8))可以

Float() 函数：将其他数据类型转换成浮点数（字符串也可，除文字类字符串😅）

---

条件判断&嵌套

条件判断

1. 单项判断 if:

#条件后记得跟进英文冒号，回车后自动缩进

if XXXX ：
缩进 print()

2. 双向判断 if…else… :

if XXXX :
	Print(XXXX)
else:
	print(XXXX)

3. 多项判断 if…elif…else… :

if XXXX :
	Print(XXXX)
elif XXXX:  #条件1不满足执行
	Print(XXXX)
elif XXXX:  #同上
	Print(XXXX)
else:   #以上条件都不满足后执行
	Print(XXXX)

if嵌套

if嵌套执行顺序：       
    #根据层级执行
    #缩进相同的命令同等级，一条一条处理
        1.先赋值
        2.代码组1——不满足60直接跳到代码组2
        3.代码组2——代码组1未满足执行

---

input()函数

input()函数 结果必须赋值

使用：

input('XXXX')
#提问&收集数据

结果赋值：

XXXX = input('XXXX')

数据类型：

input返回的类型是 str(字符串)
赋值时需要转换：
abc = 'XX'

input输出结果强制转换：

Abc = int(input('XXXX'))

解题思路例

1. 函数结果赋值
2. 搜集信息
3. 条件判断

#2.1强制转换 #另一种情况

#3.1条件判断 #另一种情况

4. 条件判断
5. 输出结果

---

列表&字典&元组

列表

列表内偏移量起始值为0

提取单个元素：

A = [01,02,03]
Print(a[0])

提取多个元素:

切片口诀：左右空，取到头；
        左取右不取    #冒号是切片

A = [1,2,3,4,5]
Print(a[:]) #打印出[1，2，3，4，5]
Print(a[2:]) #[3，4，5]
Print(a[:2]) #[1，2]
Print(a[1:3]) #[2，3]
Print(a[2:4]) #[3，4]

注：大小A是一个意思，都是列表A，为了不混淆记忆才这么标的，正式编码时要统一

列表添加/删除元素：

添加：append()函数
	用法：   列表名.append()
	注：每次只能增加一个元素
	
删除：del 语句
	用法： del 列表名[元素的索引（偏移量）]

数据类型：字典

与列表不同处：大括号

字典里的元素由 键值对 组成
#例：’小明’:95 ‘小明’ 叫键（key）95叫值（value）
字典里一样的键的键值对，后面的会覆盖前面

Len()函数 #查询字典或列表长度（元素个数）

例:

a = ['5','6','7','8']
b = {'明':12,'刚':13,'王':14}
print(len(a))   #结果4
print(len(b))   #结果3

增加键值对：

字典名['XXX'] = 值
	例：字典1['psp'] = 'ppspp'

删除键值对：

Del 字典名[键]
	例：del 字典2['03']

字典与列表的异同

不同点：列表中元素位置明确，即使元素相同

相同点：
1.修改元素都可用赋值语句完成

2.支持任意嵌套和互相嵌套例：

元组tuple

用小括号包，其他与列表一样

例：

tuple1 = ('A','B')
list2 = [('A','B'),('C','D'),('E','F')]
print(tuple1[0])      #结果：A
print(list2[1][1])      #结果：D

---

循环注

知道次数优先for循环

不知道用while循环设置`哨兵`

#哨兵意思大概是循环极限次数

---

for…in循环

第一种

for i in [1,2,3,4,5]:
    print(i)
	# i在列表里过一遍

第二种

for o in range(11):            
#range函数输出：0-10
    print('第'+str(o)+'天')

Range(x)函数:

从0生成X-1整数序列

例：range(a,b,c) 从 a 数到 b-1（取头不取尾），间隔为 C

例：
for i in range(0,10,2)
	Print(i)   #输出0，2，4，6，8

range(a,b,c)
a:计数从a开始，不填时，默认从0开始
#例如:range（1，5）#计数从1开始生成
b:计数到b结束，不包括b
#例如:range(11)#计数从0到11，不包括11
c:计数的间隔，不填时默认为1
#例如:range(0，30，5)#计数间隔为5

第三种

d = {'小明':'醋','小红':'油','小白':'盐','小张':'米'}
for q in d:
    print(d[q])
		#输出：醋，油，柴，米

第四种

for m in range(1,8):  # 为同时能运行两个循环，设新参数 m。
    if m != 4:  # 当   m != 4，执行打印语句；等于4时不打印。 # ! = 不等于
        print(m)

从零到100分别x5

for q in range(1,101):
    print(q*5)

---

while循环

第一种

a = 0          #先定义变量a，并赋值
while a < 5:   # 设定一个放行条件：a要小于5，才能办事
    a = a + 1  # 满足条件时，就办事：将a+1
    print(a)   # 继续办事：将a+1的结果打印出来

第二种

man = ''  # 注：''代表空字符串
while man != '有':  #注：!=代表不等于
​   man = input('有没有愿意为小龙女死的男人？没有的话就不能出古墓。')
print('小龙女可以出古墓门下山啦~')
a = 0  # 定义了一个变量a

第三种

while a < 5:  # 当a小于5的时候，就自动执行后续缩进部分的语句
    print('现在a的值是：' + str(a))
    #加一个print看看现在的a是多少
    a = a + 1  # 每执行一次循环，变量a的值都加1
    print('加1后a的值是：' + str(a)) 
    #加一个print看看加1后的a是多少
print(a)

从零到100分别x5

while a<101
    a=a+1
    print(a*5)

---

pop()函数

**提取:**取到元素，对列表没有影响；

**删除:**删除列表的元素。

**pop()**函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

语法：

list.pop(obj=list[-1]) 
#默认为index=-1，删除最后一个元素。
obj是可选参数，也可以指定元素对象。

例：

students = ['小明','小红','小刚']
for i in range(3):
	student1 = students.pop(0)  
	# 运用pop()函数，同时完成提取和删除。
	students.append(student1)  
	# 将移除的student1安排到最后一个座位。
	print(students)

---

布尔值与布尔运算

用数据做逻辑的过程叫 布尔运算

运算产生布尔值

布尔值分 true（真）和 false（假）

比较运算符：

等于：  ==
不等于：  !=
大于：  >
小于：  <
大于等于：  >=
小于等于：  <=

布尔运算：

bool()函数：
	括号里放入判断用数据，判断真假
		打印出来：
			print(bool(XXXX))

两个数值做比较：

And:
Ture and true	真 
True and false	假
False and true	假
False and false	假

or:
True and true	真
True or false	真
False or true	真
False or false	假

Not:
Not true	假
Not false  	真

---

break语句

循环内部使用

if…break 意思是满足某一条件，提前结束循环

for循环写法：
	for……in……:
		…
		If ….:
			Break

while循环写法：
	while XXXX：
		…
		If …:
			Break

while例子：

While ture :   #true是条件恒为真，开启无限循环，搭配break结束
	print('上供一对童男童女')  
	t = input('孙悟空来了吗')
	if t == '来了':
		break
print('孙悟空制服了鲤鱼精，陈家庄再也不用上供童男童女了')

---

concinue语句

满足条件继续执行下一个，不满足提前重置循环

continue语句搭配for循环

for...in… :
	...
	if ...:
		continue
	...

continue语句搭配while循环

while...XXXX:
	...
	if ...:
		continue
	..

例：

while True:
	q1 = input('第一问：你喜欢萝莉吗?')
	if q1 != '喜欢':
		continue
	print('答对了，行，下面第二问：')
	q2 = input('三次元还是二次元的')
	if q2 != '二次元':
		continue
	print('答对了，看来是同道中人，下面第三问：')
	q3 = input('对三次元萝莉有兴趣吗')
	if q3 == '没有':
		break
print('欢迎来到萝莉社')

---

pass语句

满足跳过，不满足继续执行

例：

a = int(input('请输入一个整数:'))
if a >= 100:
	pass        #大于等于100，终端什么都没有输出，直接结束
else:         #反之
	print('你输入了一个小于100的数字')

---

else语句

else还可搭配for循环和while循环

注：别跟傻狗似的看见 i 又迷惑了，i 等于缩进下的指令

注：a 是循环用的，没看见夹中间了吗

for例

for i in range(5):
	a = int(input('请输入0来结束循环，你有5次机会:'))
	if a == 0:
		print('你触发了break语句，循环结束，导致else语句不会生效。')    
		break
else:
	print('5次循环你都错过了，else语句生效了。')

while例

i = 0
while i < 5:
	a = int(input('请输入0结束循环，你有5次机会:')) 
	i = i+1
	If a == 0:
		print('你触发了break语句，导致else语句不会生效。')
		break
else:
	print('5次循环你都错过了，else语句生效了。')

当循环中没有碰到break语句，就会执行循环后面的else语句，否则就不会执行

---

import函数

意：导入模块函数

上例

import time   #调用time模块
time.sleep(secs)   
#使用time模块下面的sleep()函数,括号里填的是间隔的秒数（seconds，简称secs）
#time.sleep(1.5)就表示停留1.5秒再运行后续代码

模块

Random模块下 randint()函数 #随机整数

	用法：random.randint(1,100) #1-100随机整数

Time模块下 sleep()函数 #间隔时间

---

代码视觉优化

格式化字符串：

%后面有一个字母s，这是一个类型码

用来控制数据显示的类型。%s就表示先占一个字符串类型的位置

第一种

lucky = 8
print('我的幸运数字是%d' % lucky)     #输出：我的幸运数字是8
print('我的幸运数字是%d' % 8)           #输出：我的幸运数字是8
print('我的幸运数字是%s' % '816')    #输出：我的幸运数字是816
print('我的幸运数字是%d和%d' % (8,16))    #输出：我的幸运数字是8和16

%后面补上要填的内容，省掉转换类型，多个数据就放进括号

%s 字符串显示

%f 浮点数显示

%d 整数显示

第二种(更方便)

format()函数：

例：

format()格式化函数：str.format()

	print('\n{}{}'.format('数字：',0))  # 优势1：不用担心用错类型码。
		#输出：数字：0
	print('{}，{}'.format(0,1))  # 不设置指定位置时，默认按顺序对应。
		#输出：0，1
	print('{1}，{0}'.format(0,1))  # 优势2：当设置指定位置时，按指定的对应。
		#输出：1，0
	print('{0}，{1}，{0}'.format(0,1))  # 优势3：可多次调用format后的数据。
		#输出：0，1，0

	name2 =  'Python基础语法'
	print('我正在学{}'.format(name2))  # format()函数也接受通过参数传入数据。
	#输出：我正在学Python基础语法

---

函数

定义

函数是组织好的，可以重复使用的，用来实现单一功能的代码

组成

参数=自变量

定义函数

语法：

def 函数名(参数名):
	函数体
	return 语句

例：

def math(x):
# math是自己定义的函数名字（不能与内置函数重名）
# 最好体现意义
# x是自己定义的参数名，括号里参数可多可少，也可不带，命名规则和函数名相同
# 规范别忘带，括号后面还有冒号，运行出错首先检查
	y = 3*x + 5
	# 函数体：定义函数的功能
	return y
	# 返回结果y

调用函数

话不多说，直接上例：

	def math(x):
		y =  x ** 2 + x
		return y
	x=math(10)
	# 赋值X = math(10)# 这是给X赋值不等于参数x，参数x变成10，并在函数体里过了一遍
	print(x)
	# 打印出结果

也有这种例子：
	def opening():
		print('总有一种味道能温暖你～')
		print('深夜食堂正式开业啦！')
		print('欢迎来自五湖四海的你前来品尝!')
	opening()
	#定义opening()函数固定打印出这三句话
	
#也不需要return语句，原因是这个函数直接在屏幕打印出内容，不需要返回值。事实上，没有return语句的函数，Python也会在末尾隐性地加上return None，即返回None值。

参数类型

【位置参数】上例开讲：

def menu(appetizer, course):
#感觉像什么，没错，menu函数括号里的是【位置参数】，定义完后期随加随用
	print('一份开胃菜：' + appetizer)
	print('一份主食：' + course)
menu('话梅花生','牛肉拉面')
menu('花生','面')   
#如果后面括号位置参数的定义更新了，终端会按照定义顺序输出
menu(course = '面', appetizer = '花生')
#如果直接定义了，就忽视顺序，还是按顺序输出

列表传参：

def bala(food):
	for x in food:
	print(x)

fruits = ["apple", "banana", "cherry"]

bala(fruits)
#列表挨个输出

【不定长参数】上例开讲：

在不知道传递给函数的参数数量时在参数前面加个*号
例：
	def menu(*barbeque):
	#这样就可以传任意长度的参数了

返回多个值

上例才能理解：

import random 
#导入random模块
appetizer = ['话梅花生','拍黄瓜','凉拌三丝']
#随机在这里取
def coupon(money):
#定义coupon(money)函数

	if money < 5:
		a = random.choice(appetizer)
		return a
	#如果参数小于5，返回赋予a的随机值
	
	elif 5 <= money < 10:
		b = random.choice(appetizer)
		return b, '溏心蛋'
	#如果大于5小于10，返回赋予b的随机值，和第二个指定值

#第一种输出方式：
result = coupon(6)
#定义一个叫result的元组内容等与函数coupon的输出值
#括号里的money参数=6
print(result[0])
print(result[1])
#遍历result元组，挨个打印

#第二种输出方式：
dish, egg = coupon (7)
#输出的两个元素分别赋值给变量dish和egg
print(dish)
print(egg)

变量作用域

我去了，读了3个小时才完全理解

说明：
只有全局变量才能随取随用
第一点：在函数内部赋值的变量仅能在该函数内部使用 叫做：局部作用域，它们被称作【局部变量】
第二点：在所有函数之外赋值的变量，可以在程序的任何位置使用 叫做：全局作用域，它们被称作【全局变量】
注：局部作用域不能用在其他作用域的变量
上例：

rent = 3000
def cost():
	global variable_cost
#global语句，后跟需要声明是全局变量的变量
	utilities = int(input('请输入本月的水电费用'))
	food_cost = int(input('请输入本月的食材费用'))
	variable_cost = utilities + food_cost
#上面全是全局变量
	print('本月的变动成本是' + str(variable_cost))
	
def sum_cost():
	sum = rent + variable_cost
#函数下的sum属于局部变量
	print('本月的总成本是' + str(sum))
cost()
sum_cost()

函数的嵌套

上例：

def div(num1, num2):
	growth = (num1 - num2) / num2
	percent = str(growth * 100) + '%'
	return percent
#一号函数组

def warning():
	print('Error: 你确定上个月一毛钱都不赚不亏吗？')
#二号函数组

def main():
	while True:
		num1 = float(input('请输入本月所获利润'))
		num2 = float(input('请输入上月所获利润'))
		if num2 == 0:
			warning()
		else:
		print('本月的利润增长率：' + div(num1,num2))
		Break
#三号主函数组，嵌套了一号和二号，按主函数组顺序运行

main()

练习：

#定义两个函数：第一个函数功能为根据工作月数返回奖金额，第二个函数功能为打印出'该员工来了XX个月，获得奖金XXX元'。
#最后传入参数('大聪'，14)调用第二个函数，打印结果'大聪来了14个月，获得奖金2520元'

def buff(month):
	if month<6:
	a = 500
	return a
elif 6 <= month <= 12:
	b = month * 120
	return b
else:
	c = month * 180
	return c
	
def gamer():
	name = input('输入名字：')
	month = float(input('干了几个月？'))
	print(name,month,'个月','奖金:',buff(month))

gamer()

---

index函数

index()函数用于找出列表中某个元素第一次出现的索引位置。

语法为：列表名字.index(查找对象名字)

例：

num = [0,1,0,1,2]
print(num.index(1))  # 数字1首先出现的索引位置是list[1]（索引位置从0开始）
print(num.index(2))  # 数字2首先出现的索引位置是list[4]

可能比较难理解，上大例子：

import random
# 出拳
punches = ['石头','剪刀','布']
computer_choice = random.choice(punches)
user_choice = ''
user_choice = input('请出拳：（石头、剪刀、布）')  # 请用户输入选择
while user_choice not in punches:  # 当用户输入错误，提示错误，重新输入
	print('输入有误，请重新出拳')
	user_choice = input()

# 亮拳
print('————战斗过程————')
print('电脑出了：%s' % computer_choice)
print('你出了：%s' % user_choice)

# 胜负
print('—————结果—————')
if user_choice == computer_choice:  # 使用if进行条件判断
	print('平局！')
# 电脑的选择有3种，索引位置分别是：0石头、1剪刀、2布。
# 假设在电脑索引位置上减1，对应：-1布，0石头，1剪刀，皆胜。
elif user_choice == punches[punches.index(computer_choice)-1]:
	print('你赢了！')
else:
	print('你输了！')

---

try…except语句

语法：

try:
#尝试执行下列代码
	XXX
	XXX
Except 报错名称:
#报错后执行这些
	XXX
	XXX
Except 报错名称:   #可重复多个报错条件
	XXX
	XXX

方式2：将两个（或多个）异常放在一起，只要触发其中一个，就执行所包含的代码。
	except(ZeroDivisionError,ValueError):
		print('你的输入有误，请重新输入！')
    
方式3：常规错误的基类，假设不想提供很精细的提示，可以用这个语句响应常规错误。
	except Exception:
		print('你的输入有误，请重新输入！')

例子：

while True:
	try:
		age = int(input('你今年几岁了？'))
		Break     
		#是整数停止，跳过下面直接执行下段代码
	except ValueError:       
		#输入的不是整数报错后执行
		print('你输入的不是数字！')

if age < 18:
	print('不可以喝酒噢')

---

debug方法

自检清单：

1. 漏了末尾冒号
2. 缩进错误
3. 中英文符号没变
4. 没有定义变量
5. ‘==’ 和 ‘=’ 混用
6. 字符串拼接时将数字和字符串拼一起了

解决思路不清：

#号和 print() 函数搭配使用，一段段检查代码

---

类

简单总结:

类的创建：class语句

类的属性创建：赋值语句

实例方法的创建：def 名字(self):

类的实例化：实例名 = 类名( )

调用类的属性：实例名.属性

调用类的方法：实例名.方法( )

什么什么类的东西

例如电子设备，list #列表类

不同点：

现实中的类的属性和方法是客观存在的

编程中类的属性和方法是人工创建的

类是存在共同点的

第一种叫属性(attribute)

第二种叫方法(method)

例如：列表的属性有：外层有中括号，元素之间用英文逗号隔开
方法有：都可以做增删改操作（如 append、del等）

类的创建：

class Computer:    #class + 类名 + 冒号

	screen = True    #属性，通过赋值语句    ， 这句意思是有屏幕

	def start(self):    #方法创建，def + 方法名(self):
		print('电脑正在开机中……')    #方法执行过程，也叫能做什么
注：实例方法是指类中  参数  带self  的函数，是类方法的一种形式，也是最常用的用法，其他方法可查档

类的调用：

类的实例化：

在某一个类下创建个实例对象：

语法：实例名 = 类名()
例子：这是想到的实例名 = 这是刚创建的类名加个( )
意义：有了一个可调用 所属类 的 所有属性 和 方法 的实例

例例例：

class people:
# 属性:眼睛是黑色的
	eye = 'black'
	
# 方法:打印出 '吃饭，选择用筷子。'
	def chpe(self):
		print('吃饭，选择用筷子。')
		
my_eye = people()   #创建了my_eye这个实例，等于people这个类
								#也就是类的实例化
					#实例数目理论上无限，可以同时多建
print(my_eye.eye)    #实例调用属性
my_eye.chpe()   #让实例调用用chpe这个方法

创建类的两个关键点

特殊参数：self

作用：self会接收实例化过程中传入的数据，相当于先给实例占个位置

想要在类的外部调用类属性格式：self.属性名

**例：**
class Chinese:

	def greeting(self):
		print('很高兴遇见你')

	def say(self):
		self.greeting()    #person.greeting()
		print('我来自中国')
		#self被传入数据后变成person
person = Chinese()
# 创建实例person
person.say()
# 调用say()方法

初始化方法：

格式：def init(self)：

作用：当每个实例创建时，该方法内代码无需调用就会自动运行

---

类的继承&定制

所有实例的根类：object

创建类时不带括号，运行时默认为 class XXX (object): 

各级实例和各级类间的关系：

1. 子类创建的实例，同时属于父类
2. 父类创建的实例，不属于子类
3. 所有实例，都属于根类object

类的继承

基本语法：

class people:     #父级
# 属性:眼睛是黑色的
	eye = 'black'
    
# 方法:打印出 '吃饭，选择用筷子。'
	def chpe(self):
		print('吃饭，选择用筷子。')
		
class people2(people): 

# 继承，people有的people2也有

	pass
	
#验证子类可以继承父类的属性和方法，进而传递给子类的实例

doge = people2 ( )

# 子类创建的实例，从子类间接得到了父类的所有属性和方法

print (doge.eye)

#可以调用父类的属性

doge.chpe( )

      #可以调用父类的方法

函数: isinstance()

可以判断某个实例是否属于某个类
用法：
   isinstance(实例，类)
例子：
   判断 1 是否属于整数类的实例：
   isinstance(1,int)
   输出true 

多层继承

   语法：
class B(A):
…
class C(B):

作用：
类在纵向上的深度拓展

例子：
父亲继承自爷爷，儿子继承自父亲

特点：
   子类创建的实例，可调用所有层级的父类的属性和方法

多重继承

   语法：
class A(B,C,D):

作用：
   类在横向上的宽度拓展

例子：
儿子同时继承了父母的一些特征

特点：
   就近原则：在子类调用属性和方法时，优先考虑离得近的子类(即靠左)的父类。

综合例子

class C0:
    name = 'C0'
   
class C1:
    num = 1

class C2(C0):  #多层继承C0
    num = 2
    
class C3:
    name = 'C3'
    
class C4(C1,C2,C3):  #多重继承，优先选择C1
    pass

out = C4()
print(C4.name)  # 打印出C0
   print(C4.num)  # 打印出1

类的定制

新增代码

用法例子：

class Chinese:
	eye = 'black'

	def eat(self):
		print('吃饭，选择用筷子。')

class Cantonese(Chinese):    # 类的继承
	native_place = 'guangdong'    # 类的定制

	def dialect(self):    # 类的定制
		print('我们会讲广东话。')

yewen = Cantonese()
print(yewen.eye)
# 父类的属性能用

print(yewen.native_place)
# 子类的定制属性也能用

yewen.eat()
# 父类的方法能用

yewen.dialect()
# 子类的定制方法也能用

重写代码

用法例子：

class Teacher:
	face = 'serious'
	job = 'teacher'


class Father:
	face = 'sweet'
	parenthood = 'dad'

class TeacherMore(Teacher, Father):
	pass

class FatherMore(Father, Teacher):
       face = 'gentle'   #重写了值

综合例

class Student:
	def __init__(self, name, job=None, time=0.00, time_effective=0.00): 
		self.name = name
		self.job = job
		self.time = time
		self.time_effective = time_effective

	def count_time(self, hour, rate):
		self.time += hour
		self.time_effective = hour * rate

# 请你完成子类的定制（包括初始化方法和count_time函数）
class Programmer(Student):
	def __init__(self, name):
		Student.__init__(self, name, job='programmer', time=0.00, time_effective=0.00)  #修改job属性
        ##
	def count_time(self, hour, rate=1):        #rate修改为默认为1
		Student.count_time(self, hour, rate)
        
# 通过两个实例，完成子类和父类的对比（可自行验证）
student1 = Student('韩梅梅')   #优先传入name
student2 = Programmer('李雷')  #优先传入name
print(student1.job)  #打印出None
print(student2.job)  #打印出programmer
student1.count_time(10,0.8) 
student2.count_time(10)
print(student1.time_effective)  #打印出8
   print(student2.time_effective)  #打印出10

---

面向对象编程

面向对象编程，会将程序看作是一组对象的集合

面向对象编程实际上也是一种对代码的封装。
只不过，类能封装更多的东西，既能包含操作数据的方法，
又能包含数据本身。所以，代码的可复用性也更高

将代码具体的数据和处理方法都封装在类中，
让我们不用完全了解过程也可以调用类中的各种方法。

这个优势让我们可以在 Python 中轻松地调用各种标准库、第三方库和自定义模块
（可以简单理解成别人写好的类）


大概就和css里的样式差不多

---

__str__(self):

特殊方法: __str__(self)

使用print打印方法时直接打印方法return的数据，不用调用了

两个例子:

没用__str__(self)

class Book:
	def __init__(self, name, author, comment, state = 0):
		self.name = name
		self.author = author
		self.comment = comment
		self.state = state

	def show_info(self):
		if self.state == 0:
			status = '未借出'
		else:
			status = '已借出'
		return '名称：《%s》 作者：%s 推荐语：%s\n状态：%s ' % (self.name, self.author, self.comment, status)

book1 = Book(' 像自由一样美丽 ', ' 林达 ', ' 你要用光明来定义黑暗，用黑暗来定义光明 ') # 传入参数，创建实例

print( book1.show_info( ) ) #调用实例方法show_info()，打印出返回值

用了__str__(self)

class Book:
    def __init__(self, name, author, comment, state = 0):
        self.name = name
        self.author = author
        self.comment = comment
        self.state = state

    def __str__(self):
        if self.state == 0:
            status = '未借出'
        else:
            status = '已借出'
        return '名称：《%s》 作者：%s 推荐语：%s\n状态：%s ' % (self.name, self.author, self.comment, status)

book1 = Book(' 像自由一样美丽 ', ' 林达 ', ' 你要用光明来定义黑暗，用黑暗来定义光明 ') # 传入参数，创建实例

print( book1 )  # 直接打印对象即可，不能写成print(book1.__str__())

编码&文件读写

二进制

逢2进1

例：
    二进制 = 十进制
    000 = 0
    001 = 1
    010 = 2
    011 = 3
    100 = 4
    101 = 5
    110 = 6
    111 = 7

计算机最小储存单位：

【位】 也叫 【比特】(bit) 用来存放0和1
8位等于1个 字节(byte) 最常用的单位
也就是：00000000
全为1时: 11111111 等于255

编码表：

ASCII 英文大小写, 字符， 不支持中文

GB2312, GBK码 支持了中文 GBK码是GB2312的升级

Unicode码  支持了国际语言  占用空间大, 适应性强

UTF-8  支持了国际语言  是国际语言 是Unicode的升级, 两者可以非常容易互相转化, 占用空间小, ASCII码被UTF-8码包含

8进制: 0,1,2,3,4,5,6,7 表示方法
16进制: 0,1,2,3,4,5,6,7,8,9,a,b,c,d,e,f 表示方法
# 没有具体介绍

encode()和decode()

encode()编码
    用法：'准备编码的内容'.encode('编码表')
decode()编码
    用法：'准备解码的内容'.encode('编码表')

最前面有一个字母b, 比如b'\xce\xe2\xb7\xe3'
这代表它是bytes(字节)类型的数据
\x是分隔符, 用来分隔一个字节和另一个字节
网址里面有%, 它也是分隔符

文件

开 写 关

open函数

例:
open('文件路径', 'r', encoding='utf-8')
第一个参数：文件路径
    绝对路径:
        双反斜杠: 'C:\\XXX\\XXX\\XXX\\XXX.txt'
        不用处理直接读取
        单反斜杠: r'C:\XXX\XXX\XXX\XXX'
        前面加上小写R, 因为单斜杠在py里是转义字符
	相对路径：
		不在文件夹：'XXX.txt'
        在文件夹：'XXX/XXX.txt'

第二个参数：'r' 表示read 以读的模式打开文件

		'w' 表示write 写入方式 
		'w'写入模式会暴力清空掉文件，然后再写入
        'a'表示append  增加，追加内容

第三个参数：
        表示的是返回的数据采用何种编码，一般采用utf-8或者gbk。注意这里是写encoding而不是encode
        
        file1 = open('/Users/Ted/Desktop/test/abc.txt','r',encoding='utf-8') 
        file2 = file1.read()     #读取内容并放在file2里
            .read()  读取内容
            .write('准备写入的东西')  写入内容
            
        print(filecontent)
        
        file1.close()  #关闭文件  ，因为：1.计算机打开文件数量有限
                                        2.能保证写入内容已经保存好

普通写法

file1 = open('abc.txt','a') 
file1.write('写些什么') 
file1.close()

使用with关键字的写法

with open('abc.txt','a') as file1:

with open('文件地址','读写模式') as 变量名:

    #格式：冒号不能丢

    file1.write('写些什么')
    
    #格式：对文件的操作要缩进
    
#格式：无需用close()关闭

模式

模式	描述
t	文本模式(默认)
x	写模式，新增文件，如文件已存在会报错
b	二进制模式
+	打开文件进行更新(可读可写)
r	只读方式打开
rb	以二进制只读方式打开
r+	打开文件用于读写
rb+	以二进制方式文件读写
w	文件写入，存在打开从头写(原内容删除)，没有会创建
wb	二进制写入，其他原理同上
w+	文件读写，其他原理同上
wb+	二进制文件读写，其他原理同上
a	文件追加，如文件存在，新内容写在原有内容后，没有会创建
ab	二进制文件追加，其他原理同上
a+	文件读追加，其他原理同上

模块

import 模块名
（也可以导入自己写的文件做模块格式就是文件名字没有后缀）
例：
	# 文件main.py:
	import story
	
	for i in range(10):
	    print(story.sentence)
	    story.mountain()
	    A = story.Temple()
	    print(A.sentence)
	    A.reading()
	    print()

	# 文件story.py:  (也就是自定义模块)
	sentence = '从前有座山，'
	
	def mountain():
	    print('山里有座庙，')
	class Temple:
	    sentence = '庙里有个老和尚，'
	    def reading(self):
        print('在讲一个长长的故事。')

import 模块名 as 将模块名自定义化

比如：import story as s  # 将story简化成了s
           调用从 story.方法名 变为 s.方法名

from 模块名 import 模块中的方法名：

直接导入指定部分，直接使用无需加上 模块名点 的前缀
   from … import *  # 导入模块的全部方法

if__name__==’main.py‘:

if__name__=='__main.py__':   # 当这个文件直接运行时，下面的代码块开始执行
	代码块
    代码块

使用现有模块：

这有啥说的
查找模块方法
dir(模块名)
查询后结果__xx__的不用管，全英文函数是正确的
   其实不用这东西，直接谷歌就行

模块总结

import 语句

使用 import 模块名 导入模块

可以使用 import 模块名 as 自定义名 为模块取名

导入模块后，在调用模块中的变量/函数/类 的时候，要加上 模块名. 格式

from import 语句

from 模块名 import指定的内容

导入模块，并且可以直接使用指定的内容(变量，函数，类)

if __name__ == '__main__':

通常在主模块使用，表示这是“程序的入口”

当该模块作为被导入的模块时，if __name__ == '__main__' 后面的代码不会被运行