基础
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")