Python安装与配置

视频：https://www.bilibili.com/video/BV12E411A7ZQ的笔记

Linux安装python环境

建议安装桌面linux组件

1. 到官网下载linux的tar安装包

tar -zxf Python-3.7.3.tar.xz

1. 安装需要的环境附属

yum install -y gcc zlib zlib-devel openssl-devel readline readline-develide

1. 进入解压的安装包中进行编译

./configure --prefix=/usr/local/python --with-ssl

1. 编译安装

make && make install

1. 配置环境变量

export PYTHON_HOME=/usr/local/python3.10
export PATH=${PYTHON_HOME}/bin:$PATH

此时使用命令：pyhthon3 就可以进入python3环境了。

Linux下IDE的安装

1. 到pycharm下载安装包，要是.tar结尾的！

tar -zxf pycharm

1. 进入解压的文件夹中的bin目录，执行./pycharm.sh

cd pycharm

cd bin && ./pycharm.sh

Linxu创建虚拟环境

python3 -m venv ~/mypy
source ~/mypy /bin/activate

Python语法基础

设置中文

# coding:utf-8

print 输出

输出

age = 18 #创建变量
print("我的名字是%s,我的国籍是%s" %("里奥","中国")) #输出占位符
print("我的年龄是:%d岁" %age) #输出变量

• %s 字符占位符
• %d 数字占位符

sep 设置输出时连接符号

print("aaa","bbb","ccc") #python会默认用 空格 连接
print("www","baidu","com",sep=".") #sep 设置连接符号

end 设置末尾操作

因为print是默认换行的，所以可以在末尾添加 end="" 进行操作和限制

print("www",end="") #取消换行
print("wuhu",end="\t") #多一段距离
print("world",end="\n")#换行

• \t 如同按一下Tab键
• \n 进行换行

input 输入

获取用户在键盘上的输入信息

password = input("请输入密码") #获取键盘的输入，并转为string
print("您输入的密码为:%s" %password)

type() 查看数据类型

type(a) 查看变量a的数据类型

a,b,c,d = 20 , 5.5 , True , 4+3a
print(type(a),type(b),type(c),type(d))
#运行:
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

类型转换

注意：布尔型转换时，true为1flase为0。

运算符

算数运算符

两个比较特殊的
>>> 2 // 4 # 除法，得到一个整数
0
>>> 2 ** 5 # 乘方
32

成员运算符

in 如果在指定的序列中找到值，返回true，否则返回false
not in 如果在指定的序列中没有找到值，返回false，否则返回true

身份运算符

is 判断两个标识符是否引用同一个对象 x is y 类似 id(x) == id(y)
is not 判断两个标识符是否引用不同对象 x is not y 类似 id(a) != id(b)

id(x) 是取对象的内存地址

逻辑运算符

and or not 与 或 非。

逻辑运算符的特殊用法：

a = 36
a < 10 and print("hello world")
#当and前面的结果是false的情况下，后面的结果不会执行。
a = 50
a > 10 or print("hello world")
#因为前面的等式成立了，所以后面的代码并不会执行

判断语句和循环语句

循环时不需要使用{} 大括号，只需使用缩进，对其即可。

: 不能缺少代表着 条件 的结束 语句 的开始。

if True:
    print("true")
else:
    print("false")

如果出现没有对齐的情况，要么报错，要么执行位置不对：

if True:
    print("qwq")
    print("qwq")
        print("false") #第四行出现错误
else:
    print("false")
   print("false")#此行少了一格，如果没有第四行
#则会直接输出，不会进行if中的判断

多重条件判断

python的if语句中的多重判断，不是else if : 而是 elif :

score = 70
if score <=100 and score >=90:
    print("考试成绩优秀")
elif score < 90 and score >=80:
    print("还可以")
else:
    print("及格")

只有在最后时，才是else，其余的多重条件判断都用elif

if嵌套

因为没了{} 所以嵌套时要注意缩进各个代码之间的位置。

并且为了方便写代码，部分编辑器在嵌套时会有提示线

xingbie = 1 
danshen = 1
if xingbie == 1:
    print("男生") #执行语句和条件语句位置一样
    if danshen == 1:
        print("我现在单身，帅哥一枚")
    else:
        print("我不是单身")
else :
    print("女生")
    if danshen == 1:
        print("我是单身，求撩啊！")
    else:
        print("我不是单身！")

常用模块

如何导入模块：

import random    #直接导入整个库
random.randint(0,100)    #78
import getpass as gp    #给库起一个别名
gp.getpass()
from random import randint    #从库中导入某个功能
randint(0,100)

关于模块的加载：

• 当导入模块时，模块会被加载一次，并且只加载一次。
• 只加载一次可以阻止多重导入时代码被多次执行
• 如果两个文件互相导入，防止了无限的相互加载
• 模块加载时，顶层代码会自动执行，所以只将函数放入模块的顶层是良好的编程习惯

模块导入的特性

• 模块具有一个__name__特殊属性
• 当模块文件直接执行时，__name__的值为__main__
• 当模块被另一个文件导入时，__name__的值就是该模块的名字

生成随机密码

import random 导入随机数库，可以使用其中的函数了！

import random  # 导入需要用到的随机模块
from string import ascii_letters, digits  # 导入模块，第一个代表所有字母的大小写，第二个模块代表0-9
def password(x=8):  # 设置默认需要8位随机密码
    # all_chs = '123456789qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM'  # 设置随机的字符
    all_chs = ascii_letters + digits
    result = ''  # 随机生成的数值
    for i in range(x):  # 接收x的值
        ch = random.choice(all_chs)  # 从all_chs中选取随机一个字符
        result += ch  # 添加到result中
    return result

shutil模块

shell+util。工具模块。做一些复制粘贴移动等操作。

import shutil
f1 = open("qwe.txt", "rb")
f2 = open("test.txt", "wb")
shutil.copyfileobj(f1, f2)  # 将文件复制粘贴（底层方法）
f1.close()
f2.close()
shutil.copy("test.txt", "wuhu.txt")  # 将文件复制粘贴（上层方法，省事）
shutil.copy2("qwe.txt", "wuhu.txt")  # 复制粘贴文件，并且保留元数据 （stat qwe.txt查看）
shutil.move("qwe.txt", "wuhu.txt")  # 剪切文件
shutil.copymode("qwe.txt", "wuhu.txt")  # 复制文件的权限属性
shutil.copytree("/etc/systemctl", "/tmp/systemctl")  # 复制文件夹
shutil.rmtree("/tmp/systemctl")  # 删除文件夹
shutil.chown("/tmp/123.txt", user='liao123', group='liao123')  # 修改文件的所属用户和所属组
shutil.copystat("qwe.txt", "wuhu.txt")  # 将权限位最后访问时间进行复制

subprocess

• 模块用于执行系统命令
• 允许产生新的进程，连接到它们输入/输出/错误管道，并获得它们的返回代码
• 本模块指在替换几个较早的功能和模块，如os.system,os.spawn

run方法

用来在python中执行linux的命令

subprocess.run(['ls'])  # 执行一次ls
subprocess.run(['ls', '/home'])  # 使用列表的方式执行 ls /home
subprocess.run('ls /home', shell=True)  # 使用字符串执行ls /home 必须设置shell=true
subprocess.run('echo $HOME',shell=True) # 输出内置变量

程序的输出和错误

程序每运行一个命令，就会打印出命令的执行效果

result = subprocess.run(['ls'],stdout=subprocess.PIPE,stderr=subprocess.PIPE)    #此时不会显示任何东西，因为数据都在stdout和stderr中
print(result)
CompletedProcess(args='ls ..' , returncode=0)
result.args    'ls ..'
result.returncode 0        #echo $?    查看命令执行状态
result.stdout.decode()    #标准输出    存储命令打印的数据
result.stderr.decode()    #标准错误    存储命令的报错

time模块

用来获取时间和停留的模块

import time
print(time.time())  #获取当前时间戳
print(time.ctime()) #获取当前星期-月-日-时间-年份
x = time.localtime()    #以元祖的形式获取当前时间
print(x)
print(x.tm_year,x.tm_mon)
print(time.localtime(time.time())) #将时间戳转换成元祖的形式
time.sleep(1)   #到当前位置停留一秒
print(time.strftime('%Y-%m-%d %H:%M:%S'))   #自定义格式输出当前时间
print(time.strptime('2020-10-12 7:12:19','%Y-%m-%d %H:%M:%S'))  #将一段时间自定义输出
print(time.asctime(time.localtime(time.time())))    #将元祖形式的时间转换读取为当前时间

#小火车
import time
print('#' * 20, end='')
counter = 0
while 1:
    print('\r%s@%s' % ('#' * counter, '#' * (19 - counter)),end='')
    counter += 1
    time.sleep(0.3)
    if counter == 20:
        counter = 0
for i in range(10):
    priny("\r"+"#" *i,end="")
    time.sleep(0.5)

datetime

from datetime import datetime
print(datetime.now())    #获取当前时间
t = datetime.now()
print(t.date())            #获取当前年月日
print(t.time())            #获取当前时分秒
print(t.today())        #获取当前时间
print(t.ctime())        #获取当前星期-月-日-时间-年份
print(t.strftime('%Y-%m-%d %H:%M:%S'))
print(t.strptime('2020-10-20 9:19:12',"%Y-%m-%d %H:%M:%S"))

时间的计算

from datetime import datetime,timedelta
t = datetime.now()        #获取当前时间
days = timedelta(days=100,hours=2)    #设置一个时间变量，设置为100天又2小时
print(t - days)    #当前时间 - 100天又2小时

日志读取

from datetime import datetime
t9 = datetime.strptime('2020-1-4 20:00:00', "%Y-%m-%d %H:%M:%S")
t12 = datetime.strptime('2020-1-4 22:59:59', "%Y-%m-%d %H:%M:%S")
with open('myweb.log') as f:
    for i in f:
        t = datetime.strptime(i[0:17], "%Y-%m-%d %H:%M:%S")
        if t > t12:
            break
        if t >= t9:
            print(i,end='')
        # if t9 <= t <= t12:
        #     print(i,end="")

os模块

常用的简单操作

import os
os.rename("test.txt","test123.txt")        #修改名称
os.mkdir("fild")                        #创建文件夹
os.getcwd                                #获取当前目录
os.remove("test123.txt")                #删除文件
os.chdir("../")                            #改变默认目录
os.listdir("./")                        #获取目录列表
os.rmdir("fild")                        #删除文件夹
os.path.exits(路径)                        #查看文件是否存在

常用的path操作

import os
print(os.getcwd())    #打印当前所在位置
os.chdir(r'D:\Book')    #进入指定位置
totalsize = 0
for filename in os.listdir(r"C:\Windows\System32"):    #获取文件夹下的所有文件    
    totalsize = totalsize + os.path.getsize(os.path.join(r'C:\Windows\System32',filename))    #计算该文件夹下的所有文件的内存
print(totalsize)

常用的path判断操作

pickle模块

把数据写入文件时，常规的文件方法只能把字符串对象写入。其他数据需先转换成字符串再写入文件。当用pickle方法读取时也是以字典形式。

存储与写入数据

import pickle        #导入pickle文件
user = {'name':'tom','age':"20"}        #创建一个字典
with open('wuhu.txt','wb') as f:        
    pickle.dump(user,f)                    #使用dump方法存储数据,此时导入的数据在文本中是一串代码，而不是所见即所得的。
with open('wuhu.txt','rb') as f:
    adict = pickle.load(f)                #使用load方法读取数据并且赋值，取出时依然是字典类型
print(adict)

shelve模块

利用 shelve 模块，你可以将 Python 程序中的变量保存到二进制的 shelf 文件中。 这样，程序就可以从硬盘中恢复变量的数据。shelve 模块让你在程序中添加“保存” 和“打开”功能。例如，如果运行一个程序，并输入了一些配置设置，就可以将这 些设置保存到一个 shelf 文件，然后让程序下一次运行时加载它们。

import shelve        #导入模块
shelfFile = shelve.open("test.data")        #打开/创建数据存储文件
cats = ["qwq","awa","QAQ"]    #创建列表内容
shelfFile["cats"] = cats    #shelfFile对象中创建cats列表 内容为cat列表的内容
shelfFile.close()    #关闭
shelfFile = shelve.open("test.data")    #此时再打开存储文件
print(shelfFile['cats'])    #打印出内容
shelfFile.close()

要利用shelve 模块读写数据，首先要导入它。调用函数shelve.open()并传入一个文件 名，然后将返回的值保存在一个变量中。可以对这个变量的 shelf 值进行修改，就像它是 一个字典一样。当你完成时，在这个值上调用close()。这里，我们的shelf 值保存在shelfFile 中。我们创建了一个列表cats，并写下shelfFile[‘cats’] =cats，将该列表保存在shelfFile 中， 作为键’cats’关联的值（就像在字典中一样）。然后我们在shelfFile 上调用close()。

ZIPFile模块

你可能熟悉 ZIP 文件（带有.zip 文件扩展名），它可以包含许多其他文件的压缩 内容。压缩一个文件会减少它的大小，这在因特网上传输时很有用。因为一个 ZIP 文 件可以包含多个文件和子文件夹，所以它是一种很方便的方式，将多个文件打包成一 个文件。这个文件叫做“归档文件”，然后可以用作电子邮件的附件，或其他用途。

import zipfile
newzip = zipfile.ZipFile('new.zip','w')#创建压缩包名称
newzip.write('123.txt',compress_type=zipfile.ZIP_DEFLATED)    #创建压缩包
newzip.extractall()    #解压全部文件
newzip.extract('123.txt',"c:\\")    #解压指定文件到指定位置
newzip.close()

字符串

fromat()方法格式

就是给变量添加一个{}，使得通过format方法，可以将字符添加进去。

name = "张倩"
age = 25
string1 = "姓名: {} \n年龄: {}"
print(string1.format(name,age))
姓名: 张倩 
年龄: 25

甚至可以设置顺序

name = "张倩"
age = 25
string1 = "姓名: {1} \n年龄: {0}"
print(string1.format(age,name))
姓名: 张倩 
年龄: 25

甚至指定名称进行赋值

name = "张倩"
age = 25
weight = 100
string1 = f"姓名: {name} \n年龄: {age} \n体重: {weight}kg"
print(string1.format(name=name,age=age,weight=weight))

f-string()

将上面的字符串中的变量名直接带入

name = "张倩"
age = 25
print(f"姓名: {} \n年龄: {}")
姓名: 张倩 
年龄: 25

字符串的常见操作

1.find字符串查找

查找字符串中是否包含某字符串，并且输出首次出现的位置

str.find(sub[,strat[,end])

word = 't'
string = "nuttertools"
result = string.find(word)
print(result)
2

2.replace字符串替换

将当前字符串中的制定子串替换成新的子串

word = 't'
string = "nuttertools"
result = string.replace(word,"T")
print(result)
nuTTerTools

字符串的分割与拼接

1.split字符串切割

按照指定分隔符对字符串进行分割，返回由分割后的子串组成的列表

juzi = "Any harvest is not a coincidence, but daily efforts and persistence."
print(juzi.split())     #用空格分割
print(juzi.split("a"))  #用字符“a”切割
print(juzi.split("a",2))#用字符“a”切割两次

2.join字符串拼接

将指定字符串挨个插入到其他字符串中拼接成一个新的字符串

w = "-"
str1 = "Python"
print(w.join(str1))
P-y-t-h-o-n
#当然我们还可以使用 + 来拼接
x1 = "pyt"
x2 = "hon"
print( x1 + x2 )
python

删除字符串的指定字符

string1 = " Lift is short, Use Python "
print(string1.strip())        #删除两边的空格
print(string1.lstrip())        #删除前面的空格
print(string1.rstrip())        #删除后面的空格

字符串大小写转换

str1 = "i'm your father,WUHU"
print(str1.upper())
print(str1.lower())
print(str1.capitalize())
print(str1.title())
I'M YOUR FATHER,WUHU
i'm your father,wuhu
I'm your father,wuhu
I'M Your Father,Wuhu

字符串对齐

str1 = "Hello python"
print(str1.center(15,"-"))
print(str1.ljust(15,"="))
print(str1.rjust(15,"*"))
--Hello python-
Hello python===
***Hello python

字符串的特殊操作

单引与双引号中的转义字符

stu = "I'm stu"
print(stu)
#I'm stu
stu = 'I\'m stu'
print(stu)        
#I'm stu
stu = "Jason said \"I like you\"".
print(stu)
#Jason said "I like you"

字符串截取

str = "liaowuhu"
print(str[2])        #取单个字符
print(str[1:])        #取第2个之后的全部字符
print(str[1:5])        #取第2到6个字符
print(str[0::3])    #取第1到之后的全部字符，每次跳3
print(str[:7:3])    #取第8个之前的全部字符，每次跳3
print(str[0:8:2])    #取第1到8个个字符，每次跳2

字符串的一些用法

#字符串的链接
print(str + ',你好')        #直接添加字符
print(str,",芜湖~")        #直接添加字符,默认会有个空格
#字符串的复制
print(str*3)             #将字符str 复制3个并打印。

转义字符

print('wewqe\nqwe')        #\n 会给字符回车
print(r'wewqe\nqwe')    #在前面加个r 会取消全部的转义字符

字符串高级用法

循环语句

for循环

for i in range(5):    #从0开始到4，每次加1
    print(i)
#range():范围
for i in range(0,10,3):    #从0开始每次加3，峰值为10
    print(i)
for i in range(-10,-100,-30): #哪怕是负数都可以
    print(i)
name = 'liao'
for x in name:
    print(x,end='\t')        #是字符的话，会逐个打印字符串内容
a = ["aa","bb","cc"]        #列表也可以自动遍历
for i in a:                    #遍历列表的字符
    print(i)
for i in range(len(a)):        #遍历列表的数量+字符
    print(i,a[i])

while循环

i = 0
while i<5:
    print("当前是第%d次循环"%(i+1))
    print("i=%d"%i)
    i+=1

1-100求和

i = 1
sum = 0
while i <= 100:
    sum += i
    i += 1
print(sum)

while中的else

当跳出while循环时，会执行的命令。

count = 0
while count < 5:
    print(count,"small than 5")
    count += 1
else:
    print(count,"no small than 5")

break，continue和pass

break：跳出for，while循环

continue：跳过当前循环，进入下一个循环

pass：空语句，常用来当做占位符，不做任何事

1-50偶数的和

i = 0
sum = 0
while i <= 50:
    i += 1
    if i%2==1:
        continue
    sum += i
print(sum)

列表，元祖，字典

列表

List

• 列表可以完成大多数集合类的数据结构实现，列表中元素的类型可以不相同，他支持数字，字符，包括嵌套。
• 列表卸载方括号[]之间，用逗号分隔开的元素列表。
• 列表索引开头是以0开始，末尾是以-1开始。
• 列表可以使用 + 操作服进行拼接，用 * 表示重复。
• 当我们获得多个数据的时候，那么我们可以将它储存到列表中，然后直接列表访问。

#打印namelist
namelist = ["里奥",'liao',123,'test',1.213]
print(namelist[0])
print(namelist[3])
for name in namelist:        #for循环遍历
    print(name)
print(len(namelist))
length = len(namelist)        #获得长度值赋给length
i = 0
while i < length:
    print(namelist[i])        
    i += 1

增删改查

常用操作

index:查找第一次出现的下标，并且告诉你在列表中的位置。找不到就报错

哪怕设置寻找范围，数值依然不会变。

a = ["a","as","e3","wda","das","sadc"]
print(a.index("wda",2,5))
#3

count:统计出现的次数

a = ["a","as","e3","wda","das","sadc","a","a"]
print(a.count("a"))
#3

reverse:将列表所有元素反转

a = ["a","as","e3","wda","das","sadc","a","a"]
a.reverse()
print(a)
#反转输出

sort:排序输出

a = [1,213,34789,67,590,556,423,316,24,6,93]
a.sort()                #正序排序
print(a)
a.sort(reverse=True)    #倒叙排序
print(a)

二维数组

schoolName = [['123',123],[123,676],["12312","56756"]]
print(schoolName[1][0])

实例：

import random
offices = [[],[],[]]
names = ["1","2","3","4","5","6","7","8"]
for name in names:
    index = random.randint(0,2)
    offices[index].append(name)
i = 1
for office in offices:
    print("office:%d number:%d"%(i,len(office)))
    i+=1
    for name in office:
        print("%s"%name,end="\t")
    print("\n")

元组

tuple与list类似，不同之处在于tuple的元素不能修改。tuple写在小括号里，元素之间用逗号隔开。

元祖的元素不可变，但可以包含可变对象。如list

tup1 = ()
print(type(tup1))    #输出tuple
tup2 = (123)        #int
tup3 = (123,)        #tuple
tup4 = (123,48,16,"aaa")    #tuple
print(tup4(0))        #123
print(tup4(-1))        #aaa
print(tup4(1:3))    #48,16,aaa

增：

• 两个元祖添加，并且赋值给另一个元祖

• tup1 = (123,1232,312)
  tup2 = ("WQe","WDs","jy")
  tup = tup1+tup2
  #(123,1232,312,"WQe","WDs","jy")

删：

• def直接删除整个元祖

  tup1 = (123,123,54)
  del tup1
  print(tup1)    #报错

改：

• 不支持直接赋值修改

  tup1=(123,12312,12312)
  tup1[0] = 123 #这是错误的

字典

• 字典是无序的对象集合，使用键-值(key-value)存储，具有极快的查找速度。
• 键(key)必须使用不可变类型
• 同一个字典中，键(key)必须是唯一的
• 爬虫中经常使用字典。

字典的创建

info = {"name":"liao","age":19}        #定义字典
print(info["name"])                    #字典的访问
print(info.get["gender","没有这个键"])#如果没有这个键，则返回指定字符

dict创建

通过字符/列表/数字创建，并且必须是两个字符才行。字符串“ab”都必须是两位，哪怕是双数都不行。

x = dict(['ab',('name','tom'),['age','20']])
print(x)
{'a': 'b', 'name': 'tom', 'age': '20'}

fromkeys创建

如果一堆数值有的一个key是相同的，就用fromkeys

y = {}.fromkeys(("tom","jerry","bob"),19)
print(y)
{'tom': 19, 'jerry': 19, 'bob': 19}

字典的一些特殊用法

关于循环

在列表中，使用循环遍历会一次性遍历全部的数值。但是字典则不一样。

info = {"name":"liao","age":19}
print("liao" in info)        #False    因为这个in匹配的是键值
print("name" in info)        #True    name是键值
for i in info:
    print(i,info[i])
name liao
age 19

关于字符引用

info = {"name":"liao","age":19}
print("%s is %s years old" %(info['name'],info['age']))    #这样很麻烦
print("%(name)s is %(age)s years old" %info)    #字典的特殊用法

字典的函数

• len() 返回字典中元素的数目
• hash() 虽然不是为字典设计，但是可以判断是否能称为字典的键 | 函数与方法 | 作用 | 用法 | | —- | —- | —- | | get()【查】 | 括号中写入键值，获取键值的数值，并且没数据时不会报错 | get(‘键值’,’返回值’) | | keys()/values()【查】 | 只获得字典中的键值/数值 | s.keys()/s.values | | items()【查】 | 同时获得键值对，并且转为列表形式 | s.items() | | setdefault()【增】 | 直接输入键值对来添加 | s.setdefault(“name”,”age) | | dict()【增】 | 通过字符/列表/数字创建，并且必须是两个字符才行 | dict([“ab”,[“qwq”,”123”]]) | | fromkeys()【增】 | 将一堆键值设置同一个数值 | {}.fromkeys = ((“tom”,”liao”),19) | | del()【删】 | 直接删除字典 | del s | | clear()【删】 | 清空字典中的键值对 | s.clear | | pop()【删】 | 删除其中一个键值对，并且写的是键值 | s.pop(“name”) | | popitem()【删】 | 随机删除一个键值对 | s.popitem |

增删改查

增：

直接添加就好了

info = {"name":"里奥","age":18}
newID= input("请输入学号:")
info["id"]=newID
print(info["id"])
print(info)
#10
#{'name': '里奥', 'age': 18, 'id': '10'}

或者使用setdefault()

info = {"name":"里奥","age":18}
info.setdefault("gender","男")

删：

• del 删除。删除的是全部键值队。
• clear 清空。将全部键值队清空，但是字典还在。
• pop(“字典变量”) 删除该字典变量和对应的键值
• popitem(“字典变量”) 随机删除键值

改：

直接修改

info = {"name":"里奥","age":18}
info["age"] = 20
print(info["age"])

查：

• info.keys() #列出所有的键
• info.values() #列出所有的值
• info.items() #列出所有的项，每个键就是一个元祖

info = {"name":"里奥","age":18,"id":1}
print(info.keys())        #列出所有的键
print(info.values())    #列出所有的值
print(info.items())        #列出所有的项，每个键就是一个元祖
#打印遍历
for key,value in info.items():
    print("key=%s,value=%s"%(key,value))

枚举函数，同时获得下标和数值

mylist = ["a","b","c","d","e"]
for i,x in enumerate(mylist):
    print(i+1,x)

set集合

set和dict类似，也是一组key的组合，但是不存储value。由于key不能重复，所以在set中，没有重复的key。会去除重复，所以常被用来去重操作。

set是无序的，重复元素在set中自动被过滤。

集合的特殊用法

交集,并集,插补

aset = set('qwer')    #设置集合
bset = set('qwqx')
print(aset)
print(bset)
print(aset & bset)    #计算交集
print(aset - bset)    #插补操作
{'q', 'r', 'e', 'w'}
{'q', 'x', 'w'}
{'q', 'w'}                    #交集
{'q', 'w', 'x', 'e', 'r'}    #并集,数值顺序是随机的
{'e', 'r'}                    #插补，在a中有但是b中没有的

函数

Python中的函数分为以下几种类型：

• 内建函数
  • print，input这些已经给我们写好的
  • map，reduce高阶函数
• 用户自定义函数
  • 通过def，lambda关键字构造的函数
• 第三方工具包中的函数

自定义函数关键字

• 在Python中用关键字def声明函数，后面跟函数名和小括号，括号内可以放置所需参数
  • def定义的函数，是我们平时所说的函数，也是最常用的。
• 使用lambda定义的函数，被称之为匿名函数
  • 比较简洁，适用一些小功能场景，并且比较吃技术能力

def add(a,b):
    """
    输入a和b的参数，进行相加
    """
    return a+b    #返回值为a与b的和
print(add(10,20))
30

函数的参数

函数的参数分为以下几种形式：

• 必备参数：必备参数须以正确的顺序传入参数，调用时的数量必须和声明时的一样

function(a,b)

• 关键字参数：函数调用时使用等号赋值的形式传入参数

function(a=1,b=3)

• 默认参数：调用函数时，缺省参数的值如果没有传入，则被认为时默认值

def add(a=10,b=20):
    return a+b
function(15)
function(15,30)
35
45

• 不定长参数：有时候可能会需要一个函数能处理更多参数，我们不能写非常多个。使用不定长参数即可。*arg，**kwargs:加了 星号 的变量会存放所有未命名的参数，args为元祖，而kwargs会存放命名参数，即形如key=value的参数，kwargs为字典。

def add(*a):
    print(a)
add(1,2,3,4,5,6,7,8)
[1,2,3,4,5,6,7,8]

参数的顺序：def func(必备参数，关键字参数，默认参数，不定长参数)

全局变量和局部变量

name = "吴彦祖"
def func():
    name="小吴"
    print(name)
func()
print(name)
小吴
吴彦祖

在函数中的局部变量中添加global name，就是使用全局变量。

匿名函数

常用lanbda来创建匿名函数

• lambda只是一个表达式，简单
• lambda不是一个代码块，只能写有限的逻辑
• lambda函数有自己命名空间，且不能访问自有参数之外或全局命名空间里的参数

lambda 参数:函数体
lambda x:x+1

• 使得代码更简洁

x=3
l = [lambda x: x**2,lambda x:x**3,lambda x:x**4]
for i in l:
    print(i(x))
9
27
81
list1 = [{"name": "liao4", "age": 18}, {"name": "liao9", "age": 19}, {"name": "liao3", "age": 20}]
def GetKey(x):
    return x["name"]
x = sorted(list1,key=lambda x:x["name"])
print(x)

Py函数的特点

• 函数本身可以作为参数和返回值
• 函数就是面向过程的程序设计的基本单元
• 函数式编程思想更接近数学计算
• 函数式编程就是一种抽象程度很高的编程范式
• 函数式编程的一个特点就是允许把函数本身作为参数传入另一个函数，还允许返回一个函数

偏函数

当我们写一个参数比较多的函数时，如果有些参数，大部分场景下都是某一个固定值，那么为了简化使用，就可以创建一个新函数，指定我们要使用的函数的某个参数，为某个固定的值；这个新函数就是”偏函数”。

def xyz(a, b, c, d=2):
    print(a + b + c + d)
xyz(1, 4, 7)
import functools
xyz1 = functools.partial(xyz, c=10)
xyz1(1, 4)

高阶内建函数

既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数

高阶函数有以下特点：

• 变量可以指向函数
• 可以传入函数

变量指向函数

x = abs(10)
print(x)
10
f = abs
print(f(111))
111

函数中传入函数

def add(x,y,z):
    return f(x)+f(y)
print(add(5,-6,abs))
11

map函数

内建map函数，接收两个参数一个是函数，一个是Iterable对象

def f(x):
    return x**2
r = map(f,[1,2,3,4,5,6]    #前面写函数，后面写数值
list(r)
1,4,9,16,25,36

reduce函数

闭包
reduce把一个函数作用在一个序列[x1,x2,x3]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算

f(f(f(x1,x2),x3),x4)

from functools import reduce
def fn(x,y):
    return x *10 + y
reduce(fn,[1,3,5,7,9])
13579

filter函数

和map函数类似，也是一个函数一个序列。和map不同的是，filter把传入的函数依次作用于每个元素，然后根据返回值是true还是false决定保留还是丢弃该元素。

def not_empty(s):
    return s and s.strip()
list(filter(not_empty,["A","B",None,"C"," "]))
["A","B","C"]

sorted函数

排序函数，通过接收一个key函数来实现自定义的排序。自定义排序。

sorted(['bob','about','Zoo'],key=str.lower)
list1 = [{"name": "liao4", "age": 18}, {"name": "liao9", "age": 19}, {"name": "liao3", "age": 20}]
def GetKey(x):
    return x["name"]
x = sorted(list1,key=GetKey)
print(x)

enumerate函数

返回一个由元祖构成列表。

用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

user = ['tom','jerry','mariao','bob']
print(list(enumerate(user)))
for i in enumerate(user):
    print(i)
for x,y in enumerate(user):
    print(x,y)
(0, 'tom')
(1, 'jerry')
(2, 'mariao')
(3, 'bob')
0 tom
1 jerry
2 mariao
3 bob

reversed函数

翻转列表的数值，颠倒顺序

user = ['tom','jerry','mariao','bob']
print(list(reversed(user)))
['bob', 'mariao', 'jerry', 'tom']

eval

num = 10
result = eval("3 * num")
print(result)
list_str = "[1,2,3]"
tuple_str = "(1,2,4)"
dict_str = "{1:'wd',2:'dsad',3:'qwed'}"
list_eval = eval(list_str)
tuple_eval = eval(tuple_str)
dict_eval = eval(dict_str)
print("[list]序列数据：%s,序列类型%s"%(list_eval,type(list_eval)))
print("[tuple]序列数据：%s,序列类型%s"%(tuple_eval,type(tuple_eval)))
print("[dict]序列数据：%s,序列类型%s"%(dict_eval,type(dict_eval)))

eval可以不用进行强制转换，运行字符串中的程序代码。但是只能解析其中的单个字符串的信息

exec

作用和eval差不多，但是可以进行多行的字符串操作

闭包函数

在函数嵌套的前提下
内层诬数引用了外层函数的变量（包括参数)
外层函数又把内层函数当做返回值进行返回
一个函数计算一样时，但是需要内容不一样，并且多次调用，使用闭包函数就很好解决问题。

def test():
    a = 10
    def test2():
        print(a)
    return test2()
test()
10
def line_config(connect, length):
    def line():
        print("-" * (length // 2) + connect + "-" * (length // 2))
    return line
line1 = line_config("wuhu", 10)
line1()
line1()
line1()
line2 = line_config("wuhu1", 15)
line2()
line2()
line2()
-----wuhu-----
-----wuhu-----
-----wuhu-----
-------wuhu1-------
-------wuhu1-------
-------wuhu1-------

可以使用nolocal将变量设置为非内部的。

闭包案例/装饰器

def checkLogin(func):
    def Check():
        print("登录验证...")
        func()
    return Check
@checkLogin  # fss = checkLogin(fss)
# 等同于 函数名 = 闭包函数(函数名)
def fss():
    print("发说说")
@checkLogin
def ftp():
    print("发图片")
indexNumber = 2
if indexNumber == 1:
    fss()
else:
    ftp()

def ccc(char):
    def bbb(func):
        def inner():
            print(char * 30)
            func()
        return inner
    return bbb
@ccc("*")
def aaa():
    print(666)
aaa()

生成器

是一个特殊的迭代器，迭代器抽象层级更高。
迭代器的特性：

• 惰性计算数据，节省内存
• 能够记录状态，并通过next()函数访问下一个节点
• 具备可迭代特性

但是如果打造一个自己的迭代器，比较复杂。

#创建方式1
num = (i for i in range(0,100) if i % 2 == 0)
print(num)    #<generator object <genexpr> at 0x000001D5EA4E9B60>
print(next(num))    # 0
print(next(num))    # 2
for i in num:
    print(i)    # 4 6 8 10...
# 创建方式2
def test():
    print("xxx")
    yield 1
    print("a")
    yield 2
    print("b")
    yield 3
    print("c")
    yield 4
    print("d")
    yield 5
    print("e")
a = test()
print(a)
print(next(a))
print(next(a))
<generator object test at 0x000001665D6F9A10>
xxx
1
a
2

yield,可以去阻断当前的函数技行，然后，当使用next()函数，或者，next(),都会让函数继续执行，然后，当执行到下一个yield语句的时候，又会被暂停

操作方式

send() 方法

send方法有一个参数，指的是上一次被挂起的yield语句的返回值
注意第一次调用 t.send(None)

def test():
    print("xxx")
    res = yield 1
    print(res)
    print("123")
    res2 = yield 2
    print(res2)
g = test()
print(g.__next__())
print(g.send("test123"))
xxx
1
test123
123
2

close()方法

关闭生成器，本质是直接迭代到最后一个，也就是无法再调用。并不是重新回到开头

def test():
    yield 1
    print("aaa")
    yield 2
    print("bbb")
    yield 3
    print("ccc")
    yield 4
    print("ddd")
g = test()
print(g.__next__())
print(g.__next__())
g.close()

注意：如果碰到return 会直接终止 抛出StopIteration异常提示。想多次遍历，再重新创建一次即可。

递归函数

函数内部中，继续调用函数。
概念：递归，回归。

def test(n):
    if n == 1:
        return 1
    #n * n-1
    return n * test(n-1)
print(test(9))

文件操作

打开/创建文件

f = open("test.txt","w")        #打开文件，文件不存在，就新建。
f.close()

访问模式

给文件内容编辑

常用readline多使用几次，另外两个不安全并且占用内存大

#写入
f = open("test.txt","w")
f.write("芜湖~~")
f.writelines() 
f.close()                #必须执行关闭，才会保存你的操作。
#读    开始时定位在文件头部，每次执行一次向后移动指定字符数
f = open("test.txt","r")
content = f.read(3)        #读取5个字符
print(content)
f.close()
#一次读取全部信息
f = open("test.txt","r")
content = f.readlines()        #读取全部内容为列表
i = 1
for temp in content:
    print(i,temp)
    i+=1
f.close()
#读取单行信息
f = open("test.txt","r")
content = f.readline()
print(content)
content = f.readline()
print(content)
content = f.readline()
print(content)
content = f.readline()
print(content)
f.close()

文件的定位读写

tell

返回文件的当前位置，即文件指针当前位置。想获得当前读取位置时使用

with open("123.txt",encoding="utf-8")as f:
    print(f.tell())    #获取当前文件读取位置
    print(f.read(5))    #移动文件读写位置
    print(f.tell())        #读取当前位置
0
#文本
5