python笔记

基础

Linux常用dos命令

• dir：显示当前文件夹的内容
• cd：去到当前文件夹下的目录
• cd..：回到上一层目录
• 方向上下键，查看历史记录，tab自动补全
• md：创建一个文件夹
• rd：删除一个文件夹
• del：删除一个文件
• cls：清空屏幕

环境变量

配置操作系统的一些变量，建议只修改用户变量

一个环境变量可以有多个值，值与值之间使用;[英文]隔开

path环境变量

其中保存的是路径，当我们在命令行输入一个命令，系统首先会在当前目录下寻找，如果找到，直接执行命令；如果没有找到，则会依次去path环境变量的路径中去寻找，直到找到为止；如果没有找到，则报错【…命令不是内部命令…】

文本文件和字符集

• 纯文本：只能保存单一的文本内容
• 富文本：可以保存文本以外的内容（字体，颜色，图片…）

ASCII	ISO-8859-1	GB2312	GBK	Unicode
美国【128个字符】	欧洲【256个字符】	中国	中国	万国码，UTF-8

Windows	Linux
桌面操作系统占用大	服务器操作系统应用多，嵌入式应用多

Linux终端命令

命令	作用
ls	查看当前文件夹下的内容
pwd	查看当前所在的文件夹
cd [目录名]	切换文件夹，cd ~ 回到家目录
touch [文件名]	如果文件不存在，新建文件
mkdir []	创建目录
rm []，rm -r []	删除指定的文件，删除文件夹
clear	清屏

tab自动补全没有歧义的命令，上下键切换历史命令

.开始为隐藏文件，ls -a显示所有文件

结合通配符使用命令

.	？	[]	[abc]	[a-f]
代表任意个数字符	代表任意一个字符	表示可以匹配字符组中的任一一个	匹配a.b.c中的任意一个	匹配a到f范围内的任意一个字符

复制和移动命令

tree	cp	mv
用树状的形式显示文件夹下的内容	复制	移动

远程控制命令

shutdown 可以安全关闭或者重新启动系统

查看或配置网卡信息

ifconfig	查看/配置计算机当前网卡配置信息
ping 地址	检测到目标ip地址的连接是否正常

SSH

SSH客户端是一种使用SSH协议连接到远程计算机的软件程序，可靠，专为远程登录会话和其他网络服务提供安全性的协议，有效防止信息泄露

通过IP地址找到网络上的计算机

通过端口号可以找到计算机上运行的应用程序

ssh [-p port] user@remote

user：是在远程机器上的用户名

remote：是远程机器的地址，可以是IP/域名，或者别名

port：SSH Server监听的端口，默认22

scp 远程拷贝文件的命令

把本地当前目录下的01.py 文件复制到远程家目录下的 Desktop/01.py

scp -P port 01.py user@remote:Desktop/01.py

把远程家目录下的Desktop/0.py文件复制到本地当前目录下的01.py

scp -P port user@remote:Desktop/01.py 01.py

把当前目录下的demo文件夹复制到远程目录下的Desktop

scp -r demo user@remote:Desktop

把远程家目录下的Desktop复制到当前目录下的demo文件夹

scp -r user@remote:Desktop demo

基础

print(2**3)#2的3次方
print(5/2)#浮点数
print(5//2)#整数
print("我喜欢你"*100)#我喜欢你 打印100遍

在Python中定义变量不需要指定数据类型

变量类型

数字型：int，float，bool（0为假，非0为真），complex

• bool：True，False

非数字型：字符串，列表，元组，字典

使用**type()**函数可以是查看一个变量的类型

name="liming"
gender=True
print(type(name))#<class 'str'>
print(type(gender))#<class 'bool'>

变量计算

数字型变量之间可以直接计算

字符串连接使用 + 或者 *

a=10
b=True
print(a+b)#11

first_name="zhang"
last_name="wuji"
final_name=first_name+last_name
print(final_name)#zhangwuji

print(final_name*5)#zhangwujizhangwujizhangwujizhangwujizhangwuji

变量输入 input()

#输入的内容是一个字符串
password=input("请输入你的密码：")

强制转化类型

a=int("489")
age=int(input("输入你的年龄："))

变量格式化输出

name="李明"
print("我的名字叫%s,大家好！"%name)#我的名字叫李明,大家好！

多个变量输出，使用%(a,b,c)，实际上是一个元组类型

# %d：表示整数类型，06表示占6位，变量位数不够用0代替，默认是空格
count=54
num=9
print("数字是：%06d和%d"%(count,num)#数字是：000054和9

# %f：表示浮点数类型 .2表示显示小数点后2位
per=10.00000
print("百分数是：%.2f%%"%per)#百分数是：10.00%

标识符

字母、数字、下划线，不能以数字开头

python标识符区分大小写，使用小写字母，单词之间使用 _ 连接

分支

age=int(input("请输入年龄："))#75
if age>=18:
    print("你已经成年！")
    if age>=60:
        print("你已经老了！")
else:
    print("你还是个小屁孩！")
#你已经成年！
#你已经老了！

today="情人节"
if today == "愚人节":
    print("出去开玩笑")
elif today == "情人节":
    print("出去看电影")
else:
    print("待着")

逻辑运算

age=int(input("输入年龄："))
if age>0 and age<100:
    print("年龄合法！")

python_score=95
c_score=45
if python_score<60 or c_score<60:
    print("你程序编写不合格")

math_score=70
if not math_score<60:
    print("你的数学成绩是合格的！")

随机数

import random

#石头、剪刀、布 游戏
player=int(input("请输入(石头1，剪刀2，布3):"))
print("你的选择：%d"%player)
computer=random.randint(1,3)#[1,3]
print("电脑的选择：%d"%computer)
if ((player==1 and computer==2)
        or (player==2 and computer==3)
        or (player==3 and computer==1)):
    print("玩家胜！")
elif player==computer:
    print("平局")
else:
    print("电脑胜！")

循环

while

sum=0
i=0
while i<=100:
    if i%2==0:
        sum+=i
    i+=1
print("0-100偶数的和：%d"%sum)#0-100偶数的和：2550

赋值运算符：=，+=，-+，*=，/=，//=，%=，**=

continue

#输出0-10内的偶数
i=0
while i<=10:
    if i%2!=0:
        i+=1#防止死循环
        continue
    print(i)
    i+=1

break

#输出1-100内的素数
i=1
while i<=100:
    j=2
    flag=0
    while j<i:
        if i%j==0:
            flag=1
            break
        j+=1
    if flag==0:
        print(i)
    i+=1

九九乘法表

#九九乘法表
i=1
while i<=9:
    j=1
    while j<=i:
        print("%d*%d=%d\t"%(j,i,i*j),end="")#end参数表示内容输出完成后，需要继续输出的内容，默认是换行
        j+=1
    print()
    i+=1

函数

定义函数并添加文档注释

注意添加的文档注释的格式，tab

def fact(n):#形参
    """
    输入参数求阶乘
    :param n: 所要求的阶乘
    :return: 返回n!
    """
    if n==0 or n==1:
       return 1
    else:
        return n*fact(n-1)

res = fact(5)#实参
print(res)

函数调用只能在函数定义之后使用，否则会报错

函数返回值

函数可以返回不同类型的值

def update(a,b):
    if a>b:
        return a+b
    else:
        return "字符"

函数返回值是一个元组类型

def test():
    a=23
    b="9"
    return a,b

res=test()
print(type(res))#<class 'tuple'> 返回值是元组类型
print(res[0],res[1])#23 9 调用元组的元素

res1,res2=test()#可以使用多个变量一次性接收，数量要一致
print(res1,res2)#23 9

函数传参

函数参数传递的是变量的引用

def test(par):
    print("函数的参数%d的地址是：%d"%(par,id(par)))
    a=111
    print("函数内部变量%d的地址是%d："%(a,id(a)))
    return a

b=33
print("变量%d的地址是：%d"%(b,id(b)))

add=test(b)
print("函数返回值的地址是：%d"%id(add))
# 变量33的地址是：140714447853600
# 函数的参数33的地址是：140714447853600
# 函数内部变量111的地址是140714447856096：
# 函数返回值的地址是：140714447856096

缺省参数

一般情况下，参数按传进的顺序赋值；有多个缺省参数时，采用参数名赋值的方式

def test(name,gender=True,subject="计算机"):
    if gender==True:
        print("%s是男生，%s专业"%(name,subject))
    else:
        print("%s是女生，%s专业"%(name,subject))

test("小明",subject="金融")#小明是男生，金融专业
test("小红",False)#小红是女生，计算机专业

多值参数

习惯命名：*args：用来声明元组参数；**kwargs：用来声明字典参数

def test(num,*args,**kwargs):
    print("普通参数:%d"%num)
    print("元组参数:",args)
    print("字典参数:",kwargs)

test(0,4,5,6,6,name="zhangsan",age=19)

传参——元组和字典的拆包

def demo(*args,**kwargs):
    print(args)
    print(kwargs)

num_tuple=(2,4,5)
dict={"name":"张三","age":18}

demo(num_tuple,dict)#将两个变量都当做元组的元素
#((2, 4, 5), {'name': '张三', 'age': 18})
# {}

#拆包
demo(*num_tuple,**dict)
#(2, 4, 5)
#{'name': '张三', 'age': 18}

递归

#1+2+...+number
def sum_num(number):
    if number==1:
        return 1
    return number+sum_num(number-1)

print(sum_num(3))

#阶乘
def fact(n):#形参
    """
    输入参数求阶乘
    :param n: 所要求的阶乘
    :return: 返回n!
    """
    if n==0 or n==1:
       return 1
    else:
        return n*fact(n-1)

文件python模块引入

import 导入python文件模块，使用其中定义的函数

模块名（也是一个标识符）不能以数字开头，否则不能导入

pyc文件

c是compiled编译过的意思

import 导入模块之后，python解释器将模块的源码转化为字节码，后面启动的速度优化

列表List []

一个列表中可以定义不同类型的元素，一般建议是同类型的

查看方法的具体使用，Ctrl+Q

name_list=["wang","li",'yang','chen','zhu']#使用 " / ' 都可以

#1 按索引取值
print(name_list[2])

#2 根据数据内容，确定在列表中第一次出现的位置；如果内容不在列表中，则会报错
print(name_list.index('li'))

添加

#3 在末尾添加元素,修改原列表
name_list.append("张")
#如果添加的是一个列表，会把列表当成一个元素放在末尾
name_list.append(['黄','刘'])

#4 在指定位置添加数据
name_list.insert(2,'huang')

#5 在末尾添加一个列表，修改原列表
other_list=["孙",'sha']
name_list.extend(other_list)

# + 也可以添加，会返回一个新的列表，原列表没有改变
name_list+["黄","曹"]

删除

#6 根据指定数据删除列表中第一个出现的元素,如果不存在则会报错
name_list.remove("zhu")

#7 删除指定索引的元素并返回, 默认删除最后一个元素
name_list.pop()
pop_name=name_list.pop(2)

#8 清空整个列表
name_list.clear()

del从内存中删除一个变量

#9 从内存中删除一个变量,删除之后，后面就不能再使用这个变量了，会报错
# 建议使用列表自身的方法去删除元素
del name_list[2]

统计个数

#10 统计列表中的元素个数
print(len(name_list))

#11 统计某个元素出现的次数
print(name_list.count("张"))

排序 list.sort()

name_list=["li","zhang","sun","wang"]
number_list=[4,8,6,7,2]

#1 升序排列,就地排序，不会把列表复制一份，返回值为None
name_list.sort()
number_list.sort()

print(name_list)#['li', 'sun', 'wang', 'zhang']
print(number_list)#[2, 4, 6, 7, 8]

#降序
name_list.sort(reverse=True)
number_list.sort(reverse=True)

print(name_list)#['zhang', 'wang', 'sun', 'li']
print(number_list)#[8, 7, 6, 4, 2]

内置sorted(list)

不管sorted()接受的是怎样的参数，它最后都会返回一个列表

#内置函数sorted()会新建一个列表作为返回值,而原列表没有发生改变。也有reverse=''参数
new_list=sorted(number_list)
print(number_list)#[4, 8, 6, 7, 2]
print(new_list)#[2, 4, 6, 7, 8]

反转

#反转
number_list.reverse()
print(number_list)#[2, 7, 6, 8, 4]

循环遍历（迭代）

name_list=["li","zhang","sun","wang","yang"]
for item in name_list:
    print(item)

元组Tuple ()

元组中的元素不能修改，可以定义不同类型的元素

定义元组

要定义一个元素的元组，需要在元素后面加上 , 否则不是一个元组类型

#空元祖
info1_tuple=()

#普通变量类型
info2_tuple=(3)
print(type(info2_tuple))#<class 'int'>

#元组类型，只有一个元素时，添加一个,
info3_tuple=(3,)
print(type(info3_tuple))#<class 'tuple'>

info_tuple=(2,4,'1','w',4,'w')

#1 查看内容对应的第一次出现的索引
print(info_tuple.index(4))#1

#2 统计内容出现的次数
print(info_tuple.count("w"))#2

#3 统计元组长度
print(len(info_tuple))#6

循环

for it in info_tuple:
    print(it)

格式化应用

格式化字符串的%后面就是一个元组类型

print("%s 年龄是%d,身高是%d"%("西蒙斯",24,198))
#两种方法相同
info_tuple=("西蒙斯",24,198)
print("%s 年龄是%d,身高是%d"%info_tuple)

#实际上可以使用一个元组拼接一个字符串
str="%s 年龄是%d,身高是%d"%info_tuple
print(str)

元组和列表互相转化

list_p=[7,5,9]
#列表转元组
tuple_p=tuple(list_p)
print(type(tuple_p))#<class 'tuple'>

tuple_q=(3,6,12)
#元组转列表
list_q=list(tuple_q)
print(type(list_q))#<class 'list'>

字典dictionary {}

无序的键值对，print()输出时通常和定义的顺序不一致

key 必须唯一，且只能使用字符串，数字，元组

value 可以任意

取值

info={'name':'晓明','age':19}
new_info={'hobby':"篮球",'age':21}

#1 取值,key不存在会报错
print(info['name'])
#取值，当没有这个key时，设置返回值
hobby=new_info.get('hobby','没有此键')

增加/修改

#2 增加/修改
info['hobby']='篮球'
info['age']='21'

#5 更新字典，如果有重复的key，则会修改更新
new_info={'hobby':"篮球",'age':21}
info.update(new_info)
print(info)

删除

#3 删除指定的key，返回值，key不存在会报错
info.pop('age')

#删除最后一整个键值对，返回一个元组类型的键值对
type(info.popitem())#<class 'tuple'>

#4 统计键值对个数
print(len(info))

查询

#查询keys
print(info.keys())#dict_keys(['name', 'age']) 
type(info.keys() #<class 'dict_keys'>
     
#查询values
info.values()#<class 'dict_values'>
     
#查询项
print(info.items(),type(info.items()))
#dict_items([('name', '晓明'), ('age', 19)]) <class 'dict_items'>

#复制字典
info1=info.copy()

#清空字典
new_info.clear()#{}

循环

for item in info:
    print(item)    #循环打印键(默认为key)
    
for item in info.keys():
    print(item)    #循环打印键
    
for item in info.values():
    print(item)    #循环打印值
    
for item in info.items():
    print(item)    #循环打印键值对
    
for k,v in info.items():
    print(k,v)    #打印键和值

列表中存放多个字典

list1=[
    {"name":"李明",
     "id":"7521",
     "home":"china"},
    {"name":"小二",
     "age":24,
     "phone":"8542485"}
]

字符串

使用""或者''都可以，只需要把内容正确的分开就可以

常用方法

str1="我喜欢Python"
str2='我喜欢"Python"'

#按字符遍历字符串
for ch in str2:
    print(ch,end="_")#我_喜_欢_"_P_y_t_h_o_n_"_

#统计字符串的长度
print(len(str2))

#统计子串在串中出现的次数，没有查找到返回0
print(str2.count("n"))

判断数字

str_num="壹仟" #①⑴⒈  这些都是一个完整的字符，需要用Unicode字符输入

#三个方法 小数 都返回False
#纯十进制整数数字返回True,小数返回False
print(str_num.isdecimal())# "12"TRUE,    "1.2", "①", "⑴", "⒈" "壹仟" False

print(str_num.isdigit())# "12","①","⑴","⒈" True     "1.2" "壹仟" False

print(str_num.isnumeric())#"壹仟" "12","①","⑴","⒈" "1.2"  True

#查询子串第一次出现的位置,没有找到，会报错
print(str2.index("y"))
#查找指定内容第一次出现的位置，没有找到会返回-1
print(str3.find("py"))

#从右边开始查找
str2.rindex("y")
str3.rfind("py")

str3="hello pyhton"
#判断是否以指定内容开始
print(str3.startswith("hel"))

#判断是否以指定内容结尾
print(str3.endswith("on"))

#替换字符串，会返回一个新的字符串,并不会改变原来的字符串
str4=str3.replace("pyhton","world")

对齐方式

list_poem=["君不见，黄河之水天上来，奔流到海不复回。",
           "君不见，高堂明镜悲白发，朝如青丝暮成雪。",
           "人生得意须尽欢，莫使金樽空对月。",
           "天生我材必有用，千金散尽还复来。"]

for it in list_poem:
    print(it.center(50))#居中对齐
                        #设置宽度width，三个方法默认使用英文" "来填充，fillchar参数设置填充字符
    # print(it.ljust(50))#左对齐
    # print(it.rjust(50))#右对齐

去除空白字符（包括\t \n）

str5="  \t \n 32sdf\t   "
print(str5.lstrip())#去除左边空白字符
str5.rstrip()#右边
str5.strip()#左右两边，不会去除中间的空白字符

拆分 合并字符串

str_text="君不见，黄河之水天上来，奔流到海不复回。\t\n      " \
         "君不见，高堂明镜悲白发，\t朝如青丝暮成雪。      \t" \
         "    \r人生得意须尽欢，莫使金樽空对月。   \t   " \
         " \n   天生我材必有用，   千金散尽还复来。"

text_list1=str_text.split()#默认用空白字符来拆分，设置参数去拆分，返回一个字符串列表
print(text_list1)
str1=" ".join(text_list1)#合并，采用指定内容合并字符串列表中的内容成为一个字符串
print(str1)

切片字符串

str[开始索引:结束索引（并不包括）:步长]

str_num="0123456789"
print(str_num[-1])#9        -1表示最后一个索引
print(str_num[1:5])#1234
print(str_num[:5])#01234
print(str_num[-1:3])#
print(str_num[::2])#02468      没隔两个切片
print(str_num[-3:-1])#78
print(str_num[-3:])#789
print(str_num[0::-1])#0        步长-1 表示从后往前
print(str_num[-1::-1])#9876543210    
print(str_num[::-1])#9876543210    逆序

详细方法

方法	描述
string.capitalize()	把字符串的第一个字符大写
string.center(width)	返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
string.count(str, beg=0, end=len(string))	返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
string.decode(encoding=‘UTF-8’, errors=‘strict’)	以 encoding 指定的编码格式解码 string，如果出错默认报一个 ValueError 的 异 常 ， 除非 errors 指 定 的 是 ‘ignore’ 或 者’replace’
string.encode(encoding=‘UTF-8’, errors=‘strict’)	以 encoding 指定的编码格式编码 string，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’
string.endswith(obj, beg=0, end=len(string))	检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
string.expandtabs(tabsize=8)	把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8。
string.find(str, beg=0, end=len(string))	检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
string.format()	格式化字符串
string.index(str, beg=0, end=len(string))	跟find()方法一样，只不过如果str不在 string中会报一个异常.
string.isalnum()	如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
string.isalpha()	如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
string.isdecimal()	如果 string 只包含十进制数字则返回 True 否则返回 False.
string.isdigit()	如果 string 只包含数字则返回 True 否则返回 False.
string.islower()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
string.isnumeric()	如果 string 中只包含数字字符，则返回 True，否则返回 False
string.isspace()	如果 string 中只包含空格，则返回 True，否则返回 False.
string.istitle()	如果 string 是标题化的(见 title())则返回 True，否则返回 False
string.isupper()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
string.join(seq)	以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
string.ljust(width)	返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
string.lower()	转换 string 中所有大写字符为小写.
string.lstrip()	截掉 string 左边的空格
string.maketrans(intab, outtab])	maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
max(str)	返回字符串 str 中最大的字母。
min(str)	返回字符串 str 中最小的字母。
string.partition(str)	有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把 字 符 串 string 分 成 一 个 3 元 素 的 元 组 (string_pre_str,str,string_post_str),如果 string 中不包含str 则 string_pre_str == string.
string.replace(str1, str2, num=string.count(str1))	把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
string.rfind(str, beg=0,end=len(string) )	类似于 find() 函数，返回字符串最后一次出现的位置，如果没有匹配项则返回 -1。
string.rindex( str, beg=0,end=len(string))	类似于 index()，不过是返回最后一个匹配到的子字符串的索引号。
string.rjust(width)	返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
string.rpartition(str)	类似于 partition()函数,不过是从右边开始查找
string.rstrip()	删除 string 字符串末尾的空格.
string.split(str=“”, num=string.count(str))	以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+1 个子字符串
string.splitlines(keepends)	按照行(‘\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
string.startswith(obj, beg=0,end=len(string))	检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
string.strip(obj)	在 string 上执行 lstrip()和 rstrip()
string.swapcase()	翻转 string 中的大小写
string.title()	返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
string.translate(str, del=“”)	根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中
string.upper()	转换 string 中的小写字母为大写
string.zfill(width)	返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0

Python公共方法

内置函数

list1=[1,25,3,6,55,7,9]
#长度
len(list1)

#从内存删除变量,两种方式等价
del (list1[1])
del list[1]

#求最大值，只能比较相同类型的值
max(list1)
min(list1)
print(max({'a':'b','c':'x'}))#c 只根据key比较

# > < 只能比较相同类型的变量，不能比较字典
print("vsdw"<"sdc")#False
print(['3','4']<['1','6'])#False
print(['3','4']<['4','6'])#True
print((2,3)<(1,5))#False

列表、元组切片

列表、元组都是有序的，有索引值，可以进行切片

但是字典不能进行切片，字典是无序的

print([1,4,8,6,34,65,22][0:3])#[1, 4, 8]
print((2,4,56,3,23,67,8)[0:3])#(2, 4, 56)

运算符

运算符	功能	支持的数据类型
+	合并	字符串、列表、元组
*	重复	字符串、列表、元组（字典的key值唯一，所以不能使用）
in	3 in (1,3,4)	字符串、列表、元组、字典(key)
not in	3 not in (1,3,4)	字符串、列表、元组、字典(key)

for

list1=[1,4,5,6,34,23,7]
for it in list1:
    print(it)
    if(it==34):
        break
else:#在for循环正常退出时，下面的语句执行，如果因为break而退出，则下面的语句不会执行
    print("for循环正常退出")

应用场景

list_stu=[{"name":"小明",
           "age":15,
           "gender":True},
          {"name":"大佬",
           "age":18,
           "gender":False}
          ]

need_stu="圣埃蒂安"
for info in list_stu:
    if need_stu==info.get("name"):
        print("找到了：%s"%need_stu)
        break
else:
    print("没有找到：%s"%need_stu)

#没有找到：圣埃蒂安

pass

pass#暂时不知道写什么，可以使用pass,表示一个占位符，什么也不执行

TODO 注释

TODO注释很方便，可以提醒将要做的任务

# TODO(小张/1月10号前) 新建名片
if input_num in [1]:
    pass#暂时不知道写什么，可以使用pass,表示一个占位符，什么也不执行

# TODO(小刘/1月10号前) 显示所有名片
elif input_num==2:
    print("显示全部")

在PyCharm左下角的小窗口

id()

查看变量的地址

可变类型与不可变类型

可变类型（对下面两种类型的变量进行修改，内存地址不会改变）

• 列表
• 字典【字典的key只能使用不可变类型，也就是说可以是元组】

不可变类型：字符串，元组，整数

局部变量和全局变量

全局变量一般定义在上面，以便函数可以正常使用

在函数内部，可以通过全局变量的引用获取对应的数据

但是不允许直接修改全局变量的引用（不允许使用赋值语句修改全局变量的值）

num=121
def test1():
    num=110#这里并不能修改外部全局变量的值，只是一个函数内部一个新的局部变量
    print("test1--%d"%num)
def test2():
    print("test2--%d"%num)
test1()#test1--110
test2()#test2--121

特殊的列表的+=

def test(num,num_list):
    #先相加再赋值，实质上是赋值操作,所以是相加后的变量新开辟了一个变量用num去引用，并不会对传入的实参造成改变
    num+=num
    print("函数内部：%d",num)
    
    #列表+=实质上是list.extend()方法，可以对传入的实参造成改变
    num_list+=num_list
    print("函数内部：%s"%num_list)
    
gl_num=3
gl_num_list=[2,4,5]
test(gl_num,gl_num_list)
print(gl_num)#3
print(gl_num_list)#[2, 4, 5, 2, 4, 5]

global声明全局变量

num=121
def test1():
    global num#必须先声明全局变量，再进行修改
    num=110
    print("test1--%d"%num)
def test2():
    print("test2--%d"%num)

test1()#test1--110
test2()#test2--110

交换两个变量值

a=2
b=77

#方法一
# t=a
# a=b
# b=t

#方法二
# a=a+b
# b=a-b
# a=a-b

#方法三，Python独有,两种写法
a,b = (b,a)
a,b = b,a#右边同样是元组，只是省略了小括号

eval

将字符串当成有效的表达式来求值并返回计算结果

eval("1+2*9")#19
print(eval("'p'"))#p
type(eval("[1,4,3,5]"))#<class 'list'>

面向对象

dir

使用内置函数dir可以查看对象内的所有属性及方法

#查看列表的内置属性和方法
dir(list)#['__dir__', '__doc__', '__eq__','append', 'clear', 'copy'] 一部分

基础

class Cat:
    def eat(self):#self表示调用的对象
    	print("%s喜欢吃鱼！"%self.name)

cat = Cat()
cat.eat()#Tom喜欢吃鱼！
cat.name="Tom"#报错，因为添加属性在被使用之后完成

可以在类的外部添加属性，但不推荐使用，属性应该封装在内部

注意：在类的外部添加属性要在此属性被使用之前完成，否则会报错

cat.name="Tom"

初始化方法__init__(self)

__init__(self)在创建对象的时候执行

在初始化方法中定义属性

class Cat:
    def __init__(self,name):#创建对象的时候执行
        self.name=name

    def eat(self):
        print("%s喜欢吃鱼"%self.name)


cat1 = Cat("Tom")#创建对象的时候会执行初始化方法
cat1.eat()

__del__(self)

__del__(self)对象被销毁的时候执行

class Cat:
    def __init__(self,name):#创建对象的时候执行
        self.name=name
        print("%s被创建了" % self.name)

    def __del__(self):#对象被销毁的时候执行
        print("%s被销毁了"%self.name)

    def eat(self):
        print("%s喜欢吃鱼"%self.name)


cat1 = Cat("Tom")
cat1.eat()
# Tom被创建了
# Tom喜欢吃鱼
# Tom被销毁了   cat1是一个全局变量，在最后被销毁时会执行__del__()方法

__str__(self)

改写对象的输出信息

class Cat:
    def __init__(self,name):#创建对象的时候执行
        self.name=name
        
    def __str__(self):
        #必须返回一个字符串
        return "小猫[%s]"%self.name

print(cat1)#小猫[Tom]   __str__()方法进行改写之前，会输出十六进制的地址信息

class Gun:
    def __init__(self, name):
        self.name = name
        self.bullet = 0

    def shoot(self):
        if self.bullet <=0:
            return
        print("~~~啪~~~")
        self.bullet-=1


class Soldier:
    def __init__(self,name):
        self.name=name
        self.gun=None#空对象

    def add_bullet(self,count):
        if self.gun is None:
            print("士兵 %s 没有枪"%self.name)
            return
        self.gun.bullet+=count

    def fire(self):
        if self.gun is None:
            print("士兵 %s 没有枪"%self.name)
            return
        if self.gun.bullet<=0:
            print("危险，没有子弹了！！")
            return
        self.gun.shoot()
        print("~~~~无限开火中,[剩余子弹：%d]~~~"%self.gun.bullet)

私有属性和方法

声明私有属性或者方法，在前面加上__，外部不能调用，只能通过类内部的非私有方法间接使用

class Person:
    def __init__(self,name):
        self.name=name
        self.__age=17#私有属性

    def __love(self):#私有方法，外部不能调用
        print("我喜欢l")

    def print_info(self):
        print("我的名字是%s，年龄%d"%(self.name,self.__age))#类内部方法可以调用私有属性

dahai=Person("大海")
dahai.print_info()#我的名字是大海，年龄17

实际上，Python中并没有实际意义上的私有化，可以通过下面的方式调用私有属性或方法，但是不建议使用，因为是隐私，可以注意到，输入时没有提示，说明真的不建议这样使用

print(dahai._Person__age)
dahai._Person__love()

继承

class Animal:
   def __init__(self,name):
       self.name=name

   def eat(self):
       print("%s 吃"%self.name)

   def sleep(self):
       print("%s 睡"%self.name)


class Dog(Animal):#继承自Animal
   def __init__(self,name,dog_type):
       self.name=name
       self.dog_type=dog_type

   def bark(self):
       print("%s在~~汪汪汪~~"%self.name)


class Super_Dog(Dog):#继承自Dog

   def bark(self):#重写父类方法
       print("%s在~~说人话~~"%self.name)

   def fly(self):
       print("%s会飞"%self.name)

super()

class Dog:
    
    def __init__(self,name,dog_type):
        self.name=name
        self.dog_type=dog_type

    def bark(self):
        print("%s在~~汪汪汪~~"%self.name)


class Super_Dog(Dog):#继承自Dog
    
    def __init__(self,name,dog_type,skill):
        super().__init__(name,dog_type)#调用父类的初始化方法
        self.skill=skill

    def bark(self):#重写父类方法
        print("%s在~~说人话~~"%self.name)
        super().bark()# 调用父类的方法

xt = Super_Dog("啸天","拉布拉多","飞行")

私有属性、方法不能被子类的对象直接访问

子类方法可以可以调用父类的非私有方法（即使其中包含私有属性或者私有方法）

多继承

class A:
    def __init__(self,name):
        self.name=name

class B:
    def testB(self):
        print("B的方法！")

class C(A,B):
    def __init__(self):
        self.age=18

__mro__属性

C.__mro__  #多继承的子类调用父类方法的顺序
#(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)

多态

下面的代码没有多态的感觉，就算不用继承也可以正确表达，例如在java中，Person类的feedAnimal()需要传入具体的类作为参数，下面只是python语言的特性所表示出来的

class Animal:
    def __init__(self,name):
        self.name=name

    def eat(self):
        print("%s 东西"%self.name)

class Cat(Animal):
    def __init__(self,name):
        self.name=name

    def eat(self):
        print("%s 吃一条鱼"%self.name)

class Dog(Animal):
    def __init__(self,name):
        self.name=name

    def eat(self):
        print("%s 吃一个骨头"%self.name)

class Person:
    def __init__(self,name):
        self.name=name

    def feedAnimal(self,animal):
        print("%s 喂养 %s"%(self.name,animal.name))
        animal.eat()


tom = Cat("Tom")
xt = Dog("啸天")
xiaoming = Person("小明")

xiaoming.feedAnimal(tom)#小明 喂养 Tom   Tom 吃一条鱼
xiaoming.feedAnimal(xt)#小明 喂养 啸天    啸天 吃一个骨头

类对象

程序运行时，类也会被加载到内存

类对象在内存中只有一份，拥有自己的类属性和类方法

类属性

类属性通常用来记录与这个类相关的特征，类属性不会用于记录具体对象的特征

class A(object):

    obj_count = 0

    def __init__(self,name):
        A.obj_count += 1

a1=A("a1")
a2=A("a2")
a3=A("a3")
print(A.obj_count) # 3
print(a3.obj_count) # 3 通过类对象来调用类属性，向上查找机制，建议不要这样使用

如果使用 对象 修改类属性，则会添加一个对象的实例属性

a3.obj_count=99 #相当于创建一个实例属性

#类似这样
    def __init__(self,name):
        self.obj_count=99
        A.obj_count += 1

类方法

class A(object):

    obj_count = 0#类属性
    
    @classmethod
    def print_obj_count(cls):#第一个参数必须是cls,cls表示类本身，和self比较理解
        print("类创建的对象个数%d"%cls.obj_count)

A.print_obj_count()

cls

一、cls含义
python中cls代表的是类的本身，相对应的self则是类的一个实例对象。
二、cls用法
cls可以在静态方法中使用，并通过cls()方法来实例化一个对象。

静态方法

如果一个方法既不使用类属性，也不使用实例属性，就可以把这个方法声明为静态方法

class A(object):

    @staticmethod
    def method1():
        print("静态方法")

class Game(object):

    top_score = 0

    @staticmethod
    def help_info(): # 用静态方法显示游戏帮助信息
        print("多动脑，否则僵尸会吃掉你的脑子！")

    @classmethod
    def show_top_score(cls): # 类方法展示历史最高分
        print("此游戏的历史最高分:%d"%cls.top_score)

    def __init__(self,name):
        self.name=name

    def start_game(self): # 实例方法开始个人游戏
        print("%s 开始游戏了！"%self.name)

单例设计模式

类创建的对象，在系统中只有唯一的一个实例

__new__方法

创建对象时，Python首先会调用__new__方法为对象分配空间，并返回对象的引用，传递给__init__方法的第一个参数self

__new__是一个由object类提供的内置静态方法

只有继承于object的新式类才能有__new__方法，__new__方法在创建类实例对象时由Python解释器自动调用，一般不用自己定义，Python默认调用该类的直接父类的__new__方法来构造该类的实例，如果该类的父类也没有重写__new__，那么将一直按此规矩追溯至object的__new__方法，因为object是所有新式类的基类

__new__至少要有一个参数cls，代表要实例化的类，此参数在实例化时由Python解释器自动提供；__new__必须要有返回值，返回实例化出来的实例，可以return父类__new__出来的实例，或直接是object的__new__出来的实例。

如果重写__new__没有返回对象的引用，则__init__方法不会得到创建的对象self，创建对象为None

一般重写__new__方法有固定的写法

class A(object):

    def __new__(cls, *args, **kwargs): # 重写__new__方法
        return super().__new__(cls)#返回父类 __new__出来的实例
                                    # 必须传入cls参数，代表要实例化的类

    def __init__(self):
        print("创建对象时，初始化方法")

设计一个单例

class Player(object):

     # 记录单例的对象引用
     instance = None

     def __new__(cls, *args, **kwargs):
         #如果是第一次创建对象
         if cls.instance is None:
             # 返回父类创建的对象引用
             cls.instance = super().__new__(cls)
         return cls.instance

player1 = Player()
player2 = Player()
print(player1 is player2) # True

初始化方法只执行一次

class Player(object):

    init_flag = False 
    
    def __init__(self):
         if Player.init_flag:
             return
         Player.init_flag = True
         print("初始化方法")

异常

异常处理

处理已知错误

try:
    num = int(input("输入一个整数："))
    res = 10/num
    print("res=%d"%res)
except ZeroDivisionError:
    print("分母不能为0")
except ValueError:
    print("输入正确的整数")

处理未知错误

try:
    num = int(input("输入一个整数："))
    res = 10/num
    print("res=%d"%res)
except ValueError:
    print("输入正确的整数")
except Exception as res: # res 是一个错误对象
    print("出现错误",res)

完整语法

else：try中没有异常才会执行

finally：无论是否有异常都会执行

def fun():
    try:
        num = int(input("输入一个整数："))
        res = 10/num
        print("res=%d"%res)
    except ValueError:
        print("输入正确的整数")
    except Exception as res: # res 是一个错误对象
        print("出现错误",res)
    else:
        print("没有异常")
        return #finally也会执行
    finally:
        print("有无异常都会执行！")

异常传递

当函数执行出现异常，会将异常传递给函数的调用者，如果传递到主程序，仍然没有处理，程序最终终止报错

def test1():
    return 10/int(input("输入一个整数："))

def test2():
    return test1()

try:
    res = test2()
    print(res)
except Exception as e:
    print("Error!",e)

主动抛出异常

class MyException(Exception):#声明自己的异常类
    def __init__(self,info):
        pass

def input_password():
    password = input("设置密码：")
    len_pw = len(password)
    if len_pw > 8:
        print(password)
    else:
        # 创建异常对象，传入参数作为异常信息
        # ex = Exception("Exception--密码长度不足8位！")
        ex = MyException("MyException--密码长度不够！")  #使用自己的异常类
        #抛出异常，给方法的调用者
        raise ex

try:
    input_password()
except Exception as e:
    print(e)

模块

查看已安装的库：命令行 pip list

导入模块

#起别名
import 模块名 as 别名

from 模块 import 工具
from 模块 import *  #导入模块的所有工具

如果导入的模块有同名的类或函数，后面会覆盖前面的内容，通过起别名来区分

模块搜索顺序：编译器先从当前工作目录寻找，如果没有找到，则在系统目录中寻找、所以我们自己声明的模块注意不要和系统的模块重名

查看模块的完整路径

#内置属性 __file__ 
random.__file__

__name__==__main__

需求：在一个文件a导入其他文件b时，如果b中有可以直接执行的代码（并不全是纯函数或者纯类，有一些可以直接执行的测试代码），则a在执行时会同时执行b中的测试代码。我们不需要测试代码执行，该如何做？

__name__

__name__所在的文件如果被其他文件导入执行，__name__的值就是导入的文件名

__name__所在文件本身执行（测试所在文件编写的工具），__name__的值就是__main__

# py01_测试模块
def say_Hello():
    print("hello python!")

print(__name__) # __mian__  文件本身执行时
#测试代码
say_Hello()

import py01_测试模块

print("----导入模块----")
#py01_测试模块    测试模块中的__name__此时就是文件名 py01_测试模块
#hello python!
#----导入模块----

可以看到，执行时被导入的模块中测试代码也被执行了，并且此时的__name__为导入的文件名py01_测试模块，那么我们既要在被导入文件中进行测试，又不希望在主程序中执行这些测试的代码，应该如何做？

def say_Hello():
    print("hello python!")

#通常main()编写测试代码
def main():
        say_Hello()

if __name__ == "__main__":
    main()

import py01_测试模块

print("只执行自己的代码")#并不会执行测试模块中的测试代码

所以我们在编写完自己的模块之后，在后面会写这些代码

包

包的命名方式 小写字母 _

要在外界使用 包 的模块，需要在__init__.py中指定对外界提供的模块列表

mypackage

• __init__.py
• modul_a.py
• modul_b.py

__init__.py文件

from . import modul_a  #从当前目录导入响应模块
from . import modul_b

#导入自己创建的模块
from mypackage import modul_a
from mypackage import modul_b

modul_a.fun_a()
modul_b.fun_b()

下载第三方库

pip install wordcloud -i https://pypi.douban.com/simple

文件

读取文件

打开–操作–关闭

f = open("mytext",encoding="utf-8")#默认只读方式打开文件

#读取文件,以字符串的方式返回
text = f.read()
print(type(text)) # <class 'str'>
print(text)

#第一次打开文件时，文件指针会在开始的位置，执行read方法，文件指针会移动到读取文件的末尾
text2 = f.read()
print(text2) # 空

#每次打开文件之后都要关闭
f.close()

**注意：**使用 open() 方法一定要保证关闭文件对象。如果忘记关闭文件，会造成系统资源消耗，而且会影响到后续对文件的访问

完整的语法格式为：

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

参数说明:

• file: 必需，文件路径（相对或者绝对路径）。
• mode: 可选，文件打开模式
• buffering: 设置缓冲
• encoding: 一般使用utf-8
• errors: 报错级别
• newline: 区分换行符
• closefd: 传入的file参数类型
• opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。

mode 参数

模式	描述
t	文本模式 (默认)。
x	写模式，新建一个文件，如果该文件已存在则会报错。
b	二进制模式。
+	打开一个文件进行更新(可读可写)。
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

默认为文本模式，如果要以二进制模式打开，加上 b 。

file 对象

file 对象使用 open 函数来创建，下表列出了 file 对象常用的函数：

序号	方法及描述
1	file.close()关闭文件。关闭后文件不能再进行读写操作。
2	file.flush()刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
3	file.fileno()返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。
4	file.isatty()如果文件连接到一个终端设备返回 True，否则返回 False。
6	file.read从文件读取指定的字节数，如果未给定或为负则读取所有。
7	file.readline读取整行，包括 “\n” 字符。
8	file.readlines读取所有行并返回列表，若给定 sizeint >0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。
9	file.seek移动文件读取指针到指定位置
10	file.tell()返回文件当前位置。
11	file.truncate从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后后面的所有字符被删除，其中 windows 系统下的换行代表2个字符大小。
12	file.write(str)将字符串写入文件，返回的是写入的字符长度。
13	file.writelines(sequence)向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

with语句

with语句可以自动管理上下文资源，不论什么原因跳出with块，都能确保文件的正确关闭

#复制文件
with open("mytext",'rb') as src_file:
    with open("mytext_cpoy",'wb') as target_file:
        target_file.write(src_file.read())

os模块管理文件

1	os.remove(path) 删除路径为path的文件。如果path 是一个文件夹，将抛出OSError; 查看下面的rmdir()删除一个 directory。
2	os.rename(src, dst) 重命名文件或目录，从 src 到 dst
3	[os.mkdir(path[, mode])](https://www.runoob.com/python3/python3-os-mkdir.html) 以数字mode的mode创建一个名为path的文件夹.默认的 mode 是 0777 (八进制)。
4	os.rmdir(path) 删除path指定的空目录，如果目录非空，则抛出一个OSError异常。

import os

#打开记事本
# os.system("notepad.exe")

#打开QQ
os.startfile("C:\\Program Files (x86)\\Tencent\\QQ\\Bin\\qq.exe")