Python学习

1.变量类型：

整数型（int）

浮点型（float）

布尔型（boolean）：Ture（男）/False（女）。开发中用sex，gender表示性别

sex = True
gender = False

字符串（string）：使用单引号或双引号。可以单引号与双引号互相嵌套。

str1 = "那样的夜色太美，你太温柔"
str2 = '才会在刹那之间，只想和你到白头'
str3 =  '"那样的夜色太美，你太温柔"'
ste4 = "'才会在刹那之间，只想和你到白头'"

列表（list) 用[ ]表示

name_list = ['金金','银银']

元组（tuple） 用( )表示

age_tuple = (18,19,20,21,22)

字典（dictionary） 用{ key : value, key1 : value1 }表示

person = {'name':'金金','age':'21'}

查看数据类型type（）

type(str1)
#string
type(name_list)
#list
type(age_tuple)
#tuple
type(person)
#dict

2.标识符和关键字

标识符的创建要做到“见名知意”。

标识符的创建注意三点：

1.标识符由字母、数字、下划线三部分组成。

2.不能以数字开头。

3.标识符不能为关键字。

分为“大驼峰”和“小驼峰”。其中大驼峰为所有单词的开头字母都要大写，如：NameList，AgeList。小驼峰为首单词首字母开头小写，其余字母开头大写，如：nameList，ageList。

3.强制类型转换（需要什么类型前面就写相对应的关键字）

3.1强制转换为整型 int（）

小数转换为整型时只保留其整数部分。

布尔类型转换为整型时，True对应1，False对应0。

字符串转换为整型时，只有字符串是整数时才能转换为对应的int类型。

3.2强制转换为浮点型 float（）

整型转换为float时，小数点后面加一个0。

字符串转换为float时，只有字符串是小数时才能转换为对应的int类型。

3.3强制转换为布尔型bool（）

整型转换为布尔型时，除了0以外的所有正数和负数都是True，只有0是False。

浮点型转换为布尔型时，除了0.0以外的所有数都是True，只有0.0是False。

当列表，元组，字典中内容为空时，转换为布尔型时是False。内容不为空时是True。

#什么情况下时False
print(bool(''))
print(bool(""))
print(bool(0))
print(bool(0.0))
print(bool({}))
print(bool([]))
print(bool(()))

3.4强制转换为字符串型str（）

整型转换为字符串（大部分应用场景）

4.运算符

4.1算数运算符(以a=5，b=9为例)

加	+	a+b=14
减	-	a-b=-4
乘	*	a*b=45
除	/	a/b=0.56
整除	//	a//b=0
取余	%	a%b=5
幂	**	a**b(5的9次方)
小括号	( )	提高运算优先级，先算括号里面的，（1+2）*3

两个字符串做加法运算相当于把两个字符串拼接。

str1 = '那样的夜色太美，'
str2 = '你太温柔。'
str3 = str1 + str2
print(str3)   #那样的夜色太美，你太温柔。

数字和字符串做加法运算时会报错。

数字和字符串做乘法运算时，会重复字符串。

str1 = '靓仔'
str2 = str1*5   #靓仔靓仔靓仔靓仔靓仔

4.2赋值运算符

+=	a=a+2	a+=2
-=	a=a-2	a-=2
*=	a=a*2	a*=2
/=	a=a/2	a/=2
//=	a=a//2	a//=2
%=	a=a%2	a%=2
**=	a=a**2	a**=2

4.3比较运算符（只返回True或False，判断正确返回True，判断错误返回False）

例如a = 10 ，b = 20

==	等于	a == b(False)
<=	小于等于	a <= b(True)
>=	大于等于	a >= b(False)
!=	不等于	a != b(True)
<	小于	a < b(True)
>	大于	a > b(False)

4.4逻辑运算符

and	与	两边都是True，才是True。只要有False，总体就为False。
or	或	两边只要有一边为True则为True。两边全是False时，总体为False。
not	非	not True --> False；not False --> True

and前面为False时，后面代码不会执行。

or前面为True时，后面代码不会执行。

a = 50
a > 10 and print("靓仔") #输出靓仔
a < 10 and print("靓仔") #没有输出

a > 10 or print("靓仔") #没有输出
a < 10 or print("靓仔") #输出靓仔

5.输入输出

5.1普通输出

print（'我今年10岁了'）
print（'我今年11岁了'）
print（'我今年12岁了'）

5.2格式化输出（ %s表示字符串，%d表示数值。）

age = 10
print("我今年%d岁了" % age)
age += 1
print("我今年%d岁了" % age)
age += 1
print("我今年%d岁了" % age)

name = '张麻子'
print('我的名字是%s,我今年%d岁了' % (name,age))

#我今年10岁了
#我今年11岁了
#我今年12岁了
#我的名字是张麻子,我今年12岁了

5.3输入 input（）

phoneNumber = input('请输入你的紧急联系人电话:') #phoneNumber是字符串，后面不可以为%d
print("我的紧急联系人电话是：%s" %phoneNumber)

6.流程控制语句

if语句

if 条件：
    条件为True时执行的代码

age = 21
if age >= 18:
    print('你可以去网吧了！')

if-else语句

if 条件：
    条件为True时执行的代码
else：
    条件为False时执行的的代码

age = 21
if age >= 18:
    print('你可以去网吧了！')
else
    print('快去写作业！！！')

elif语句

score = int(input('请输入你的成绩：'))
if score >= 90:
    print('优秀')
elif score >= 80:
    print('良好')
elif score >= 70:
    print('中等')
elif score >= 60:
    print('及格')
else:
    print('不及格')

for语句

for 变量 in 遍历的对象:
    方法体

word = '那样的夜色太美，你太温柔。'
for i in word
    print(i)

range语句

#遍历[0,5) 左闭右开区间
for i in range(5):
    print(i)

#遍历[1,5) 左闭右开区间
for i in range(1,6):
    print(i)

遍历[1,10)，首项为1，公差为3的递增数列 
for i in range(1,10,3):
    print(i)

7.高级数据类型

7.1字符串高级

len() #获取字符串长度
find() #查找指定内容是否字符中，在，返回指定内容下标；不在返回-1
startswith()  endswith() #判断字符串是不是以xxx开头，返回True or False
count("海"，0，5) #返会start和end之间指定内容出现的次数
replace() #替换字符串中指定内容
spilt() #通过参数内容切割字符串，分割字符串之后会返回一个列表
upper()  lower() #将字符串中的大小写互换
strip() #用于移除字符串头尾指定的字符(默认为空格)或字符序列
join() #字符串拼接
capitalize() #首字母变为大写，其余字母为小写
casefold()# 全变为小写
title()# 开头字母全为大写
swapcase()# 大写变小写，小写变大写

name = '唐 伯 虎 点 秋 香 是 一 个 legend !'
print(len(name))
# 26
print(name.find('有'))
# -1
print(name.startswith('唐'))
# True
print(name.count('唐'))
# 1
print(name.replace('唐','小唐'))
# 小唐 伯 虎 点 秋 香 是 一 个 legend !
print(name.split( ))
# ['唐', '伯', '虎', '点', '秋', '香', '是', '一', '个', 'legend', '!']
print(name.upper())
# 唐 伯 虎 点 秋 香 是 一 个 LEGEND !
print(name.strip('!'))
# 唐 伯 虎 点 秋 香 是 一 个 legend 
sign = '*'
print(sign.join(name))
# 唐* *伯* *虎* *点* *秋* *香* *是* *一* *个* *l*e*g*e*n*d* *!

7.1.1左中右对齐

center(width,fillchar='') #中对齐
ljust(width,fillchar='') #左对齐
rjust(width,fillchar='') #右对齐
zfill(width) #用0填充左侧

7.1.2替换

expandtabs() #用空格来替换tab，尽量使用空格
replace(old,new,count=-1)
translate(table)

table = str.maketrans("ABCDEFG","1234567")
new = "I love FDKQ".translate(table)
#I love 64KQ

#判断字符是否为python标识符
import keyword
keyword.iskeyword("if")

#使用strip去除字符串中的元素，默认为空白

7.1.3拆分和拼接

partition("")#使用特定字符来进行切分,从左往右
rpartition()#从右往左

spilt(sep=None,maxsplit=-1)
rspilt()
spiltlines()#将字符串按行进行分割，结果以列表的形式返回

join()#进行拼接,可迭代对象可以是元组或列表
website = ".".join(["www","baidu","com"])
website = ".".join(("www","baidu","com"))
#www.baidu.com

7.1.4格式化字符串

year = 2023
"今年是{}年".format(year)

test = "1+2={}，2的平方={}，3的立方={}".format(1+2,2*2,3*3*3)
1+2=3，2的平方=4，3的立方=27

"{1:@>10}{0:@<10}".format("250","520")
@@@@@@@520250@@@@@@@

"{:+}{:-}".format("520","-205")#'+520 -205
#千分位分隔符
"{:,}".format(12345)#不能加""
"{:_}".format(12345)
#精度
"{:.2f}".format(3.1415)#3.14 保留两位小数
"{:.2g}".format(3.1415)#3.1 小数点前后一共有两位数
"{:.6}".format("who are you")#who ar 取字符串的前六位

7.2列表高级

7.2.1列表的遍历

a = [1,2,3,4,5,"唐伯虎点秋香"]
#列表的遍历
for each in a:
    print(each)
#通过 列表名[下标索引]来获取列表元素
print a[5]  #唐伯虎点秋香

7.2.2列表的切片

print(a[:3])
print(a[1:3])
print(a[2:])
print(a[::-1])   #将列表倒序
print(a[0:5:2])  #间隔为2，下标索引从0-5
print(a[:])  #打印全列表

7.2.3列表末尾追加元素使用 .append() 和 .extend()

a.append(59)
a.extend([6,19])#添加的是一个可迭代对象
a[len(a):] = [6]#使用切片在末尾添加
#使用inset()对指点位置插入元素
inset(索引,插入值)
a.insert(a[len(a)],33)#插入末尾

7.2.4删除替换元素

b = ["钢铁侠"，"灭霸","美国队长","绿巨人","奇异博士","黑豹"]
#   .remove()来删除元素
b.remove("钢铁侠")
#   .pop()删除指定位置元素
b.pop(2) #删除下标索引为2的元素
#   .clear()删除全列表

b[1] = "蜘蛛侠"  #灭霸替换为蜘蛛侠
b[3:] = ["武松","林冲","鲁智深"]  #替换从下标为3开始的元素

7.2.5使用 .sort()对列表进行排序（从小到大） .reverse() （从大到小）= .sort(reverse = True)

7.2.6嵌套列表

a = [[1,2,3],
     [4,5,6],
     [7.8,9]]
# [[1, 2, 3], [4, 5, 6], [7.8, 9]]

#嵌套列表遍历
for i in a:
    for each in i:
        print(each)

a[行索引][列索引]  #获取某一元素

x = [1,2,3]
y = [1,2,3]  #但x和y不一样，不是等价关系

7.2.7浅拷贝和深拷贝（得到两个独立的列表）

x = [[1,2,3],
     [4,5,6],
     [7,8,9]]
x[1][1] = 99
#通过.copy()和切片的方法来进行拷贝（处理一维列表）
y = x.copy()
y = x[:]
[[1, 2, 3], [4, 99, 6], [7, 8, 9]]#x
[[1, 2, 3], [4, 99, 6], [7, 8, 9]]#y


#使用.deepcopy()处理嵌套列表
import copy
y = copy.deepcopy(x)
[[1, 2, 3], [4, 99, 6], [7, 8, 9]]#x
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]#y

7.2.8列表推导式

a = [1,2,3,4,5]
for i in range(len(a))
    a[i] = a[i] * 2

a = [i * 2 for i in a]
# [2,4,6,8,10]     

x = [ i for i range(10)]   
#[0,1,2,3,4,5,6,7,8,9]

x = [ i + 1 for i range(10)] 
x = []
for i in range(10):
    x.append(i + 1)

x = [[1,2,3],
     [4,5,6],
     [7,8,9]]
x = [row[1] for row in x]
#[2,5,8]

7.2.9嵌套列表

#创建一个嵌套列表
a = [0]
for i in range(3):
    a[i] = [0] * 3
print(a)
#[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
S = [a[0] * 3 for i in range(3)]

words = ["Fantastic","Great","Good","Company","Die","Service"]
select_wrod = [i for i in words if i[0] == "G"] 

7.3序列高级

a = [1,2,3,4,5,6]
del a[2]#根据下标删除元素
del a[::2]  #[2, 4, 6]
del x[:2]   #[3, 4, 5, 6]
#使用切片删除
x[1:4] = [] #[1, 5, 6]

a = [6,5,1,2,8,9,4,5]
b = sorted(a)
#sorted函数不会改变原来列表
print(b)  #[1, 2, 4, 5, 5, 6, 8, 9]
print(a)  #[6, 5, 1, 2, 8, 9, 4, 5]
#reversed 返回的是一个迭代器。将列表元素倒序，而不是从大到小排序
reversed(a)   #<class 'list_reverseiterator'>
print(list(reversed(a)))  #[5, 4, 9, 8, 2, 1, 5, 6]

#  enumerate()返回一个枚举对象
word = ["activate","reason","quiet","dumity"]
print(type(enumerate(word))) #<class 'enumerate'>
print(list(enumerate(word)))
#[(0, 'activate'), (1, 'reason'), (2, 'quiet'), (3, 'dumity')]
print(list(enumerate(word,10)))
#[(10, 'activate'), (11, 'reason'), (12, 'quiet'), (13, 'dumity')]

# zip()返回一个迭代器
a = [1,2,3]
b = [4,5,6]
c = [7,8,9,10]
print(zip(a,b))  #<zip object at 0x0000016ABA5BFD40>
print(list(zip(a,b)))#[(1, 4), (2, 5), (3, 6)]
print(list(zip(a,c)))#[(1, 7), (2, 8), (3, 9)] 优先最短列表
import itertools
print(list(itertools.zip_longest(a,b,c)))
#[(1, 4, 7), (2, 5, 8), (3, 6, 9), (None, None, 10)]

#map()返回一个迭代器
mapper = map(ord,"dsbshdhfb")
print(list(mapper))
mapper = map(pow,[1,2,3],[1,2,3]) #[1, 4, 27]
print(list(mapper))

#filter()返回一个由结果为真的元素组成的迭代器
list(filter(str.islower,"HjGUsjjha"))
#['j', 's', 'j', 'j', 'h', 'a']

迭代器vs迭代对象

迭代器只能操作一次，迭代对象可重复使用

iter()函数将迭代对象变为迭代器

next()函数可将迭代器中元素逐一提取

7.4字典高级

7.4.1创建字典的六种方法

a = {"云长":"关羽","翼德":"张飞","玄德":"刘备"}
a = dict(云长="关羽",翼德="张飞",玄德="刘备")
a = dict([("云长","关羽"),("翼德","张飞"),("玄德","刘备")])
a = dict({"云长":"关羽","翼德":"张飞","玄德":"刘备"})
a = dict(zip(["云长","翼德","玄德"],["关羽","张飞","刘备"]))
a = dict({"云长":"关羽","翼德":"张飞"},玄德="刘备")

7.4.2 字典的增删改查

#  formkeys(iterable,[,values])
a = dict.fromkeys("jadaasd",123)
#  {'j': 123, 'a': 123, 'd': 123, 's': 123}
a["b"] = 45
#  {'j': 123, 'a': 123, 'd': 123, 's': 123, 'b': 45}

# pop(key,[,default])
a.pop("j")
# popitem() 删除最后一个加入字典的键值对
a.popitem()

del a["b"]#删除指定元素
del a  #删除整个字典
a.clear()#清空字典中的所有元素

使用update()来增加多个键值对
a.update({"r":"157","p":"139"})
a.update(r="157",p="139")

使用get()方法来查字典中的键值对
a.get("i","找不到")
a.setdefault("i","code")
{'j': 123, 'a': 123, 'd': 123, 's': 123, 'b': 45, 'r': '157', 'p': '139', 'i': 'code'}

7.5集合高级（集合中元素无序且唯一）

#创建集合的三种方法
a = {"I","love","python",}
{s for s in "python"}  #{'y', 'n', 'p', 'o', 'h', 't'}
set("python“) #{'y', 'n', 'p', 'o', 'h', 't'}

.isdisjoint()  #来判断两集合是否相关
a.issubset(b)  #a是否是b的子集
a.issuperset(b) #a是否是b的超集
a.union(b) #求a与b的并集
a.intersection(b) #求a与b的交集
a.difference(b) #求a与b的差集（属于a但不属于b）
#################以上方法都支持多参数
a.symmetric_difference(b)#排除a，b集合共有的元素，其余元素组成的集合

7.5.1集合的增删改查

set() #创建的集合可变
frozenset() #创建的集合不可变
a = frozenset("njsjsdhv")
# frozenset({'n', 'j', 'h', 'd', 'v', 's'})

update()
s = set("xzcja")
s.update([1,1,2],"32")
print(s)

#通过以下方法来更新set()集合
intersection_update() #交集
difference_update() #差集
symmetric_difference_update() #排除a，b集合共有的元素，其余元素组成的集合
add("59")#将59作为字符串插入到集合，update("59")是将5和9分别插入集合

#删除元素
remove() #指定元素不存在，抛出异常
discrad() #指定元素不存在，静默处理
pop() #随机从集合中弹出一个元素
clear() #将集合清空

7.5.2字典的键和集合的元素是可哈希的，列表是可变的不能哈希

hash() #可获取一个对象的哈希值
#通过frozenset()创建嵌套集合
x = {1,2,3}
x = frozenset(x)
y = {x,4,5}
#{frozenset({1, 2, 3}), 4, 5}

8.函数

8.1创建和调用函数

def myfunc():
    pass

def myfunc(name):
    for i in range(3):
        print("my name is {}".format(name))

def myfunc(name):
    for i in range(3):
        print(f"my name is {name}")
myfunc("qqbb")

def div(x,y):
    if y == 0:
        return "除数不能为0!"
    else:
        return x/y
print(div(4,2))

8.2函数参数

8.2.1位置参数和关键字参数

def myfunc(o,v,s):
    return "".join((s,v,o))
myfunc(" python"," love"," I")
#关键字参数。位置参数必须在关键字之前
myfunc(o=" I",v=" love",s=" python")
 I love python
#可以在参数里面定义默认参数
def myfunc(o,v="吃",s="苹果"):
    return "".join((s,v,o))
print(myfunc("香蕉"))

8.2.2收集参数

#在形参中使用*起到打包效果
#收集参数可以打包为一个元组使用*
def myfunc(*args):
    print("有{}个参数".format(len(args))) #传入了多少个参数
    print(f"有{(len(args))}个参数")
def myfunc(*a,b,c):
    print(a,b,c)
myfunc(1,2,3,b=4,c=5)  #(1, 2, 3) 4 5

#收集参数可以打包为字典使用**
def myfunc(**kwargs):
    print(kwargs)
myfunc(a=1,b=2,c=3) #{'a': 1, 'b': 2, 'c': 3}

def myfunc(a,*b,**c):
    print(a,b,c)
print(myfunc(1,4,5,6,x=2,y=3)) #1 (4, 5, 6) {'x': 2, 'y': 3}

#在实参中使用*起到解包的效果
args = (1,2,3,4)
def myfunc(a,b,c,d):
    print(a,b,c,d)
myfunc(*agrs) #1 2 3 4

kwargs = {"a":"1","b":"2","c":"3","d":"4"}
myfunc(**kwargs) #1 2 3 4

8.2.3作用域

#局部作用域（局部变量），作用域仅限于该函数。
def mydef():
    x = 1968
    print(x)
mydef()  #1968
#全局作用域（全局变量）
x = 880
def myfunc():
    print(x)
myfunc() #880
#在函数中局部变量会覆盖同名的全局变量

#global()
x = 880
def myfunc():
    global x
    x = 1968
    print(x)
myfunc() #1968
print(x) #1968

8.2.4嵌套函数

def funA():
    x = 520
    def funB():
        x = 1314
        print("in funB x is ",x)
    funB()
    print("in funA x is ",x)
funA()
#in funB x is  1314
#in funA x is  520

#使用nonlocal语句,在内部函数中修改外部函数的作用域
def funA():
    x = 520
    def funB():
        nonlocal x
        x = 1314
        print("in funB x is ",x)
    funB()
    print("in funA x is ",x)
funA()
#in funB x is  1314
#in funA x is  1314

8.2.5 LEGB规则

Local 局部作用域

Enclosed 嵌套函数的外层作用域

Global 全局作用域

Build-In 内置作用域

8.3闭包

def funA():
    x = 880
    def funB():
        print(x)
    return funB
print(funA())  #<function funA.<locals>.funB at 0x0000013997761430>
print(funA()()) #880
***这儿很重要！！！！***
#作为外层函数的作用域（变量）会以某种形式保留下来
funny = funA()
funny()

def power(exp):
    def exp_of(base):
        return base ** exp
    return exp_of

square = power(2)
cube = power(3)

print(square(5)) #25
print(cube(5))   #125

#nonlocal()可以将嵌套函数的内层函数修改到外层的变量
def outer():
    x = 0
    y = 0
    def inner(x1,y1):
        nonlocal x,y
        x += x1
        y += y1
        print(f"现在,x={x},y={y}")
    return inner
move = outer()
move(1,2)
move(2,2)

import time
def time_master(func):
    print("开始运行程序")
    start = time.time()
    func()
    stop = time.time()
    print("该程序运行结束")
    print(f"该程序运行时间{(stop - start):.2f}秒。")

def myfunc():
    time.sleep(3)
    print("Hello world")

time_master(myfunc)

#开始运行程序
#Hello world
#该程序运行结束
#该程序运行时间3.01秒。

8.4装饰器（闭包+函数当参数）

8.5 lambda表达式（匿名函数）

lambda arg1,arg2,arg3,...,argnN : expression
def <lambda>(arg1,arg2,arg3,...,argN):
    return expression

def square(y):
    return y*y

square = lambda y : y * y

y = [lambda x : x * x,2,3]#lambda表达式可以放入列表内，普通函数不行
y[0](y[1])   #4
y[0](y[2])   #9

8.6生成器

def counter():
    i = 0
    while i <= 5:
        yield i
        i +=1        #此时counte是一个生成器<class 'generator'>
for i in counter():
    print(i)

8.6.1生成器表达式

t = (i ** 2 for i in range(10))
print(next(t))

一次只生成一个数据

8.7递归（函数调用自身的过程）

#迭代实现阶乘
def factIter(n):
    result = n
    for i in range(1,n):
        result *= i
    return result
print(factIter(5))
#递归实现阶乘
def factReter(n):
    if n == 1:
        return 1
    else:
        return n * factReter(n-1)
print(factReter(5))

#斐波那契数列（迭代的效率比递归高很多！！！！）
def fibIter(n):#迭代
    a = 1
    b = 1
    c = 1
    while n > 2:
        c = a + b
        a = b
        b = c
        n -= 1
    return c
print(fibIter(12))

def fibIter(n):#递归
    if n == 1 or n == 2:
        return 1
    else:
        return fibIter(n-1) + fibIter(n -2)
print(fibIter(12))

#编写函数文档（在函数最上面）
def exchange(dollar,rate = 6.23):
    """
    功能：美元转换人民币
    参数：
    -dollar美元数量
    -rate汇率
    :return:
    -人民币数量
    """
    return  dollar * rate

help(exchange)
exchange(dollar, rate=6.23)
    功能：美元转换人民币
    参数：
    -dollar美元数量
    -rate汇率
    :return:
    -人民币数量

8.8内省

函数名._annotations_  #来查看函数的类型注释
exchange._annotations_

8.9高阶函数（functools高阶函数库）

functools.reduce()函数
import functools
def add(x,y):
    return x + y
result = functools.reduce(add,[1,2,3,4,5])
print(result)

#10的阶乘  3628800
factorial = functools.reduce(lambda x,y:x*y,range(1,11))
print(factorial)

8.9.1偏函数

square = functools.partial(pow,exp = 2)
print(square(3))

cube = functools.partial(pow,exp = 3)
print(cube(3))

8.9.2 @wraps装饰器

#普通装饰器
import time
def time_master(func):
    def call_fun():
        start = time.time()
        print('开始调用函数了')
        func()
        stop = time.time()
        print(f"运行时间为{(stop - start):.2f}秒")
    return call_fun
@time_master
def myfunc():
    time.sleep(2)
    print("你演的夜色太美，你太温柔")
myfunc()
print(myfunc.__name__)  #call_fun

# @wraps装饰器用来修饰装饰器的装饰器
import functools
import time
def time_master(func):
    @functools.wraps(func)  #找到函数内调用的函数
    def call_fun():
        start = time.time()
        print('开始调用函数了')
        func()
        stop = time.time()
        print(f"运行时间为{(stop - start):.2f}秒")
    return call_fun

@time_master
def myfunc():
    time.sleep(2)
    print("你演的夜色太美，你太温柔")
myfunc()
print(myfunc.__name__) #myfunc

9.永久储存

9.1文件读写

#使用open()打开文件，write()写入内容、writelines()可以写入多个内容。
file = open("python.txt","r+")
file.write("《致橡树》\n")
file.writelines(['我如果爱你绝不学攀援的凌霄花\n','借你的高枝炫耀自己\n'])
file.close()
file.seek()  #修改文件指针（0指初始位置，1指当前位置，2指文件末尾）

9.2文件系统路径（pathlib）

from pathlib import Path
print(Path.cwd())
p = Path('F:\Python\python项目\DaydayUp')  #生成一个路径对象
#F:\Python\python项目\DaydayUp
q = p / "python.txt"  #使用 / 来拼接路径
print(q)
#F:\Python\python项目\DaydayUp\python.txt

p.is_dir()   #判断路径是否是文件夹
q.is_file()  #判断路径是否是文件
p.exists()   #判断路径是否存在
p.name       #获取路径的最后一部分
q.stem       #获取文件名
q.suffix     #获取文件后缀
q.parent     #获取其父级目录
q.parents    #获取逻辑祖先构成的一个不可变序列
ps = q.parents
for each in ps:
    print(each)
#F:\Python\python项目\DaydayUp\python.txt
#F:\Python\python项目\DaydayUp
#F:\Python\python项目
F:\Python
#F:\
q.parents还支持索引
q.parts      #将路径的各个组件拆分成元组
q.stat()       #查询文件或文件夹的信息

9.2.1 相对路径（以当前目录为基准一级一级推导）vs绝对路径（文件真正存在的路径）

./    表示当前目录
../   表示上一级目录
resolve() #将相对路径转化为绝对路径
iterdir() #获取当前路径下的所有文件和文件夹
print(type(p.iterdir()))  #<class 'generator'>
for each in p.iterdir():
    print(each)
print([i for i in p.iterdir() if i.is_file()])  #列表推导式，筛选出所有是文件
#[WindowsPath('F:/Python/python项目/DaydayUp/demo_1.py'), WindowsPath('F:/Python/python项目/DaydayUp/demo_2.py'), WindowsPath('F:/Python/python项目/DaydayUp/demo_3.py'), WindowsPath('F:/Python/python项目/DaydayUp/demo_4.py'), WindowsPath('F:/Python/python项目/DaydayUp/extractScript.py'), WindowsPath('F:/Python/python项目/DaydayUp/lalala.py'), WindowsPath('F:/Python/python项目/DaydayUp/python.txt'), WindowsPath('F:/Python/python项目/DaydayUp/test.py')]
mkdir()   #创建文件夹
rmdir()   #删除文件夹
unlink()  #删除文件

p = Path(.)
p.glob("*.txt") #在当前目录下查询所有.txt文件，返回一个对象。
list(p.glob("*.txt"))

9.3 with语句和上下文管理器

with open ("python.txt","r+") as f:
    f.writelines(["我如果爱你\n","绝不学痴情的鸟儿为绿荫重复单调的歌曲\n"])

#pickle 永久储存python对象
import pickle
x,y,z = 1,2,3
s = "qqppla"
l = ["潜入海底",3.14,15926]
d = {'0':'张飞','1':'绣花','2':'真不错'}
with open('data.pkl','wb') as f:
    pickle.dump((x,y,z,s,l,d),f)   #将obj对象序列化存入已经打开的file中
    pickle.dumps()                 #将obj对象序列化为string形式，而不是存入文件中


with open('data.pkl','rb') as f:
    (x,y,z,s,l,d)= pickle.load(f)  #将file中的对象序列化读出
    print(x,y,z,s,l,d,sep="\n")    

1
2
3
qqppla
['潜入海底', 3.14, 15926]
{'0': '张飞', '1': '绣花', '2': '真不错'}

10.异常

#使用try except来捕获异常
try:
    测试范围
except [expression [as identifier]]:
    异常处理代码

try :
    0/1
    7788 + "qqppla"
except(ZeroDivisionError,TypeError,ValueError):
    pass

#try except else（发生异常执行except内容，没发生异常执行else内容）
try :
    0/1
except():
    print("逮到了")
else:
    print("没逮到")
#try except finally（无论异常是否发生都会执行finally内容）

10.1异常的嵌套

try :
    try :
        1/0
    except:
        print("内部异常")
    520 + "qqppla"
except:
    print("外部异常")
finally:
    print("收尾工作")

内部异常
外部异常
收尾工作

11.类和对象

#对象 = 属性（静态特征） + 方法（对象所能做的事）
class Person:
    head = 1
    eyes = 2
    legs = 2
    finger = 10
#每个与类相关联的方法调用都自动传递实参self，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。
    def eat(self): 
        print("人可以吃驴肉火烧")
    def drink(self):
        print("可以喝可口可乐")
    def run(self):
        print("可以跑马拉松")
    def play(self):
        print("可以打打篮球")
p = Person()
p.play()

11.1封装（通过类将对象的相关属性和方法打包到一起）

11.2继承（继承一个类可以使用该类的属性和方法）

class A():
    x = 520
    def today(self):
        print("今天是个好日子")
class B(A):
    pass
b = B()
b.today()  #今天是个好日子
#A是B的父类

isinstance() #判断一个对象是否属于某一个类
issubclass() #检测一个类是否是某个类的子类

#多重继承：一个子类可以继承多个父类
class A():
    x = 520
    def today(self):
        print("今天是个好日子")
class B():
    x = 7788
    y = 1978
    def today(self):
        print("今天要下雨了")
#类的多重继承顺序是从左到右，且在当前类查不到属性和方法再去下一个类中查找
class C(A,B):
    pass
c = C()
print(c.x)
c.today()
print(c.y)
520
今天是个好日子
1978

#组合
class cat:
    def say(self):
        print("喵喵喵喵")
class dog:
    def say(self):
        print("汪汪汪汪")
class pig:
    def say(self):
        print("哼哼哼哼")
class garden:
    c = cat()
    d = dog()
    p = pig()
    def say(self):
        self.c.say()  #self实例对象和类的方法绑定！！！！
        self.d.say()
        self.p.say()
g = garden()
g.say()

#利用空类生成的实例来模拟字典
class C:
    pass
c = C()
c.x = "七七八八啦"
c.y = 520
c.z = [1,2,3,4]

###__init__() 构造函数
class C:
    def __init__(self,x,y):
        self.x = x
        self.y = y
    def add(self):
        return self.x + self.y
    def mul(self):
        return self.x * self.y
c = C(2,3)
print(c.add())  #5
print(c.mul())  #6

#重写（对父类的某个属性或方法不满意的话，可以重写同名的属性进行覆盖）
class D(C):
    def __init__(self,x,y,z):
        C.__init__(self,x,y)
        self.z = z
    def add(self):
        return C.add(self) + self.z
    def mul(self):
        return C.mul(self) * self.z
d =D(2,3,5)
print(d.add())   #10
print(d.mul())   #30

#钻石继承
class A:
    def __init__(self):
        print("我是A")
class B1(A):
    def __init__(self):
        A.__init__(self)
        print("我是B1")
class B2(A):
    def __init__(self):
        A.__init__(self)
        print("我是B2")
class C(B1,B2):
    def __init__(self):
        B1.__init__(self)
        B2.__init__(self)
        print("我是C")

c = C()
我是A
我是B1
我是A
我是B2
我是C

#调用super()函数来解决钻石继承问题
#super()严格遵循MRO顺序
#C.mro()
class A:
    def __init__(self):
        print("我是A")
class B1(A):
    def __init__(self):
        super().__init__()
        print("我是B1")
class B2(A):
    def __init__(self):
        super().__init__()
        print("我是B2")
class C(B1,B2):
    def __init__(self):
        super().__init__()
        print("我是C")

c = C()
我是A
我是B2
我是B1
我是C

#Mixin  添加某个功能后期加上去的父类
class Animal:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def say(self):
        print(f"我叫{self.name},我今年{self.age}岁了")
class FlyMixin:
    def fly(self):
        print("我还可以飞飞")
class Pig(FlyMixin,Animal):
    def call(self):
        print("我是一只特立独行的猪")
p = Pig("七七八八啦",3)
p.call()    #我是一只特立独行的猪
p.say()     #我叫七七八八啦,我今年3岁了
p.fly()     #我还可以飞飞

test

class Display():
    def display(self,message):
        print(message)
class LoggerMixin:
    def log(self,message,file_name = "llla.txt"):
        with open(file_name,"a") as f:
            f.writelines(message)
    def display(self,message):
        super().display(message)
        self.log(message)
class MySubclass(LoggerMixin,Display):
    def log(self,message,):
        super().log(message,file_name="qqbb.txt")
subclass = MySubclass()
subclass.display("This is s test")

print(MySubclass.mro())

#[<class '__main__.MySubclass'>, <class '__main__.LoggerMixin'>, <class '__main__.Display'>, <class 'object'>]

11.3多态

Square\circle\Triangle重写了构造函数和area()方法，此之谓多态
class Shape:
    def __init__(self,name):
        self.name = name
    def area(self):
        pass
class Square(Shape):
    def __init__(self,length):
        super().__init__("正方形")
        self.length = length
    def area(self):
        return self.length * self.length

class Circle(Shape):
    def __init__(self,radius):
        super().__init__("圆形")
        self.radius = radius
    def area(self):
        return 3.14 * self.radius * self.radius

class Triangle(Shape):
    def __init__(self,base,height):
        super().__init__("三角形")
        self.base = base
        self.height = height
    def area(self):
        return self.base * self.height / 2

s=Square(5)
c=Circle(5)
t=Triangle(6,3)

print(s.name)     #正方形
print(s.area())   #25

class Cat():
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def intro(self):
        print(f"我是一只小猫，我的名字是{self.name},我今年{self.age}岁了")
    def say(self):
        print("喵喵喵喵")
class Dog():
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def intro(self):
        print(f"我是一只修狗，我的名字是{self.name},我今年{self.age}岁了")
    def say(self):
        print("汪汪汪汪")
class Pig():
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def intro(self):
        print(f"我是一只大猪，我的名字是{self.name},我今年{self.age}岁了")
    def say(self):
        print("哼哼哼哼")
c = Cat("阿拉蕾",3)
d = Dog("阿斯顿",5)
p = Pig("白菜",2)
def animal(x):
    x.intro()
    x.say()

animal(p)

#我是一只大猪，我的名字是白菜,我今年2岁了
#哼哼哼哼

11.4私有变量(通过某种手段使对象里的某种属性和方法没法被外部访问)

name mangling(在变量或函数前面加上__)
class C:
    def __init__(self,x):
        self.__x = x
    def set(self,x):
        self.__x = x
    def get(self):
        print(self.__x)
c = C(250)
c.set(520)
c.get()
print(c.__dict__)  #{'_C__x': 520}

#__slots__来避免创造字典产生的空间浪费
class C:   #类C中只有x、y两种属性且已经规定死，不可以动态添加属性！！！！！
    __slots__ = ['x','y']
    def __init__(self,x):
        self.x = x

c = C(550)
print(c.x)
c.z = 666  #AttributeError: 'C' object has no attribute 'z'
#继承父类的__slots__属性不会在子类中生效！！！！
class D(C):
#C是D的父类且C类中有__slots__,但可以在D类中实现动态添加属性，存在__dict__!!!!

11.5魔法方法

#对象的诞生流程是先调用__new__()方法
class CapStr(str):
    def __new__(cls, string):
        string = string.upper()
        return super().__new__(cls,string)
cs = CapStr("dog")
print(cs)   #DOG
#对象销毁的时候会调用__del__()方法（当一个对象没有任何引用的时候才会被销毁）
class C:
    def __init__(self):
        print("我来啦")
    def __del__(self):
        print("我走啦")

c = C()   #我来啦
del c     #我走啦

#利用__del__()方法实现对象的重生

 11.6属性访问

class C():
    def __init__(self,name,age):
        self.name = name
        self.__age = age#私有变量

c = C("怪然",18)
# hasattr用来检测C是否有name这个属性
print(hasattr(c,"name"))
# getattr是用来获取某个属性值
print(getattr(c,"name"))
#使用"_类名__属性 "来得到私有变量
print(getattr(c,"_C__age"))
#setattr是用来设置指定属性的值
setattr(c,"_C__age",19)
print(getattr(c,"_C__age"))
# delattr是用来删除类的属性
delattr(c,"name")

class C:
    def __getitem__(self, index):
            print(index)
c = C()
c[2:8]   #slice(2, 8, None)切片操作相对于是slice的语法糖

s = "Apple Like Banana"
print(s[2:6])
print(s[slice(2,6)])
s[7:]
s[slice(7,None)]
s[::4]
s[slice(None,None,4)]

class Double:
    def __init__(self,start,stop):
        self.value = start - 1
        self.stop = stop
    #定义__iter__(self)说明该类是一个可迭代对象
    def __iter__(self):
        return self
    # 可迭代对象定义__next__(self)说明该类是一个迭代器
    def __next__(self):
        if self.value == self.stop:
            raise StopIteration
        self.value += 1
        return self.value * 2
d = Double(1,8)
for i in d:
    print(i,end=' ')   #2 4 6 8 10 12 14 16 

class Power:
    def __init__(self,exp):
        self.exp = exp
    # *是指位置参数  **是指关键字参数
    #def __call__(self, *args, **kwargs):
    def __call__(self, base):
        return base ** self.exp
square = Power(2)
cude = Power(3)

print(square(3))
print(cude(4))

 11.7property()函数

优势1：简化代码，避免复杂的魔法三件套

优势2：property函数的参数是函数，相对于装饰器。

class C:
    def __init__(self):
        self._x = 250
    def getx(self):
        return self._x
    def setx(self,value):
        self._x = value
    def delx(self):
        del self._x
    x = property(getx,setx,delx)

c = C()       
print(c.x)                 #250 
print(c.__dict__)          #{'_x': 250}

class D:
    def __init__(self):
        self._x = 250
    @property
    def x(self):
        return self._x
    @x.setter
    def x(self,value):
        self._x = value
    @x.deleter
    def x(self):
        del self._x
d= D()                       
print(d.x)                 #250
print(d.__dict__)          #{'_x': 250}
del d.x                    #{}
print(d.__dict__)