标签：lists 参数表 sts date for 运行时 精确 去除 没有
常见的DOS命令
文本文件和字符集
编译型语言和解释型语言
Python的用途(排名tiobe)
web应用
爬虫程序
科学计算
自动化运维
大数据
云计算
人工智能
桌面软件/游戏等
Python(anaconda navigator)结合pycharm
pyCharm创建项目→create project→需要选择project interpreter(exciting interpreter选择python.exe)
Python的基本语法
pyCharm的常用快捷键
字面量和变量、标识符
number值、String值都可以作为字面量
变量用于保存字面量
标识符(自主命名的内容都属于标识符)
命名规则
数值
在Python中数值分为三种:整数、浮点数、复数
在Python中所有的整数都是int类型
如果数字的长度过大,可以使用下划线_作为分隔符
十进制的数值不能以0开头
对浮点数进行计算的时候,可能会得到一个不精确的值.比如:
c=0.1+0.2
print(c)
可以通过在字符串前添加一个f来创建一个格式化字符串,在格式化字符串中可以直接嵌入变量
a="abc"
b=124
c=f"hello {a},{b}"
print(c)
# 该输出呈现的是字符串
print(f"a={a},b={b}")
可以通过.format格式化输出,在格式化字输出中可以直接嵌入变量
a="name"
b=123
print("a={},b={}" .format(a,b))
布尔型 bool 只能装(True/False)
序列的分类
可变序列
不可变序列
列表 list [1,2,3,4...]
# 按照下标获取列表中的字段
nameList = ["王大锤", "唐马儒", "鹿晗", "蔡徐坤", "李现"]
print(nameList[2])
# 列表可以保存不同类型的元素
a = ["abcd", 11, True]
# len() 获取列表的长度
l = len(nameList)
print(l)
# 表示从后向前获取元素,获取2个元素,-1表示倒数第一个
print(nameList.stus[-2])
# 表示获取元素(包括起始位置,不包括结束位置),stus函数在做切片操作时,总会返回一个新的列表,不会影响原来的列表
print(nameList.stus[1:4])
# 如果省略结束为值,则会一直截取到最后,同理如果省略开始位置,则会从第一个元素开始截取
print(nameList.stus[1:])
# 表示从开头位置截取到第5个位置,并且是每下两个截取一个(通俗的讲就是隔一个截取)
print(nameList.stus[1:5:2])
# 将两个列表拼成一个列表
lists=[1,2,3]+[4,5,6]
# 可以重复列表(表示123123)
lists=[1,2,3]*2
# min()获取列表中的最小值
# max()获取列表中的最大值
#获取列表指定元素在列表中的位置
print(nameList.index("王大锤"))
# 查找列表中指定元素 ,第二个参数表示查找的起始位置(包括开始,但是如果第三个刚好是查找的元素,则忽略),第三个参数表示查找的结束位置(不包括)
print(nameList.index("王大锤",3))
# 查找元素在列表中出现的次数
print(nameList.count("王大锤"))
# 使用循环遍历列表,这里的i表示下标,range里面表示列表的长度
for i in range(len(nameList)):
print(nameList[i])
# 此种遍历列表的方式,name表示的集合中可变的值(集合长度决定该值的个数),nameList是一个集合
for name in nameList:
print(name)
# append() 向列表中添加元素,不需要返回值
nameList.append("渣渣辉")
for name in nameList:
print(name, end=‘ ‘)
# extend() 将一个列表添加到另一个列表中,并且是加入到另一个列表的末尾位置
nameList2 = ["吴亦凡", "周杰伦", "古天乐"]
nameList.extend(nameList2)
print(nameList)
# insert() 在指定的位置前插入元素
nameList.insert(1, "东尼大木")
print(nameList)
# 修改元素,需要通过下标来修改
nameList[0] = "张全蛋"
print(nameList)
# in 判断 指定的元素是否被包含在列表中,包含就返回true,不包含就返回false
print("jack" in nameList)
# not in 判断指定元素是否被包含在列表中,不包含返回true,包含了返回false
print("jack" not in nameList)
# 删除列表中元素,根据下标进行删除
del nameList[0]
print(nameList)
# pop()函数，删除最后一个元素,括号内如果加上参数的话,跟del功能就类似,负值表示倒数,正值表示正数
nameList.pop()
print(nameList)
# remove() 根据指定的元素来删除,完全匹配
nameList.remove("吴亦凡")
print(nameList)
# sort排序
number = []
for i in range(10):
number.append(random.randint(0, 100))
number.sort()
# reverse=True,由大到小排列
number.sort(reverse=True)
print(number)
# reverse() 也可以作为函数使用,表示反转列表
nameList.reverse()
列表的嵌套
a = [[1, 2, 3], [11, 22, 33], [33, 66, 99]]
print(a[0])
print(a[1])
print(a[2][2])
集合
# 使用{}来粗创建集合,集合的顺序是由python解释器自己去排列的
# 通过set可以将序列和字典转换为集合
# 使用set()函数将字典转换为集合的时候,只会包含字典的键
# 使用len()函数获取集合中元素的数量
# 使用add()函数可以向集合中添加元素
# 使用update()函数将另一个集合添加到当前集合中
# 使用pop()函数随机删除集合中的一个元素
# 使用remove()删除指定的元素name
print(info.remove(name))
# 使用clear()函数清空集合
# 使用copy()函数对集合进行浅复制
集合的运算
# 对集合做运算时,不会影响原来的集合,而是将运算结果返回
# &交集运算
s={1,2,3}
s2={3}
result=s & s2
print(result) 输出3
# |并集运算 表示合并集合
# -差集运算 表示返回减号前面有的,后面没有的值
# ^亦或集运算 表示返回两个集合中除了共有的值
# <=检查一个集合是否是另一个集合的子集,意思就是当前集合中的元素是否全部在另一个集合中出现,那么当前的集合就是另一个集合的子集
字符串
在Python中字符串需要使用引号引起来,相同的引号不能嵌套使用
单双引号不能跨行使用,需要使用\来进行连接
使用三重引号来表示一个长字符串,并且三重引号可以换行,会保留字符串中的格式.
字符串也可以进行加法运算,作为拼接
变量中存放字符串,如果使用*表示复制 例:a="abc" c=a * 3 print(c)
%3.5s表示3-5个字符(多个截去,少了补空格)
"hello %4s"%123 可以以数字作为占位符
"hello %4s"%123.34 也可以以浮点数作为占位符
"hello %4fs"%234.4 以浮点数作为占位符,并且小数保留4位
"hello %4ds"%234.4 整数占位符
# %s表示指定一个占位符,单独的s表示任意字符
b="hello %s"%"world"
print(b)
# %s指定的占位符可以容纳多个字符,字符间用逗号隔开
c="hello %s say %s"%("world","goodbye")
print(c)
# %3s表示限制占位3位,如果不够空格补充,超过则保留3位
d="hello %3s"%"world"
print(d)
字符串常用函数
str="thinking in python"
print(str.find("in"))
# find() 在指定的范围查找,包含开始不包含结束
print(str.find("in",0,4))
# count() 检测指定字符串,在字符串中出现的次数
print(str.count("in"))
# replace() 替换操作,将字符串中的内容,替换成新的内容
print(str.replace("python","C++"))
print(str.replace("in","out"))
# split() 分割操作,按照指定的内容,将字符串分割
print(str.split("i"))
a="good good study day day up"
print(a.split(" "))
# capitalize() 把字符串第一个字符改成大写的
print(str.capitalize())
# title() 将字符串每个单词的首字母改成大写
print(str.title())
# startwith() 检测字符串是否以指定的内容开头,是则返回True,否则返回False
print(str.startswith("think"))
# endswith() 检测字符串是否以指定内容结尾,是返回True,否则返回False
print(str.endswith("on"))
# lstrip() 去除字符串左边的空格
a=" asdw "
print(a.lstrip())
# rstrip() 去除字符串右边的空格
print(a.rstrip())
# strip() 去除字符串两边的空格
print(a.strip())
# isalpha() 判断字符串中是字母返回True,不是就返回False
str2 = "abc123"
print(str2.isalpha())
# isdigit() 判断字符串中全部是数字字符返回True,不是返回False
str3 = "123456789"
print(str3.isdigit())
# isspace() 判断字符串中只包含空格返回True,不包含就返回False
str4=" "
print(str4.isspace())
字符串的下标应用
下标
s="abcdef123啊啊啊"
# 根据下标为0,获取字符串中第一个字符
print(s[0])
print(s[6])
截取字符串 s[a,b]
strs="sdfsaf"
# 做截取操作时,包含开始,不包含结束
print(s[0:3])
# 从指定位置截取到字符串末尾
print(s[3:])
# 表示截取倒数第二个字符,-2表示倒数第三个字符,以此类推
print(s[0:-1])
元祖
判断数据类型 type(变量名)
函数
input() 实现输入
sum() 求和
a=123
b=345
# sum里面第一个参数表示列表(相加),第二个表示相加的数
c=sum([11,2],(4))
print(c)
range(start,stop,step)
用途 用来生成一个自然数的序列
三个参数的含义
一般通过range()函数创建一个执行指定次数的for循环
自定义函数
语法:def 函数的名称():
调用方式:函数名()
自定义函数的四种定义方法
# 创建函数的时候,也可以定义默认形参,如果用户传递了参数则默认值没有任何作用;如果用户没有传递,那么默认值就会生效
def info(name="吴鹏",age=19):
print(name,age)
info()
# 在定义函数时,可以在形参前边加上一个*,这样这个形参将会获取到所有的实参,它会将所有的实参保存到一个元祖中,如下:*a会接受所有的位置实参,并且将这些实参统一保存到一个元祖中
def fn(*a):
print("a={}" .format(a),type(a))
fn(1,2,3,4,5,6)
# 定义一个函数,可以求任意个数字的和
# 带*号的参数只能是一个,如果带*号的在形参的中间,那么后面的形参相对应的实参必须要有赋值的形式进行传递
def sum(*a):
result=0
for fn in a:
result+=fn
print(result)
sum(10,20,30,40)
# 参数的解包,*t会自动将序列中的元素默认作为参数传递,要求序列中元素的个数必须和形参的个数一致
def fn4(a,b,c):
print(a)
print(b)
print(c)
# 使用列表
t=(10,20,30)
fn4(*t)
# 使用字典 **d的功能跟上面的类似
d={"a":100,"b":200,"c":300}
fn4(**d)
返回值
数据类型转换
转成整型 int()
转成浮点 float() 转换过程跟int类似,不同的是,小数点会用0代替
转成字符串 str()
转成bool值 bool()
算数运算符
转义字符
关系运算符 <,>,==,!==,<=,>=
逻辑运算(and,or,not)
分支结构
if
闰年的规则:
循环结构
for...in... 1. in后面跟的是序列 2. in后面也可以是一个字符串 3. in后也可以是range()函数
模块的引入
random
从另一个文件中引入函数(如果引入所有使用*)
python的相关练习
# 计算所有的奇数之和(使用while)
num = 0
sum = 0
while num <= 100:
if num % 2 != 0:
print(num)
sum += num
num += 1
print("所有奇数和:{}".format(sum))
# 计算所有的奇数之和(使用for...in...)
sum = 0
# 与while的区别:num不需要定义变量为0
for num in range(101):
if num % 2 != 0:
print(num)
sum += num
num += 1
print("所有的奇数之和:{}".format(sum))
# 使用for动态打印矩形
# 外层循环控制行,内层循环控制列
num=input("请输入边数:")
num=int(num)
for i in range(num-1):
for j in range(num):
print("*",end="")
print("")
# 动态打印正三角
num = input("请输入三角的边数:")
num = int(num)
for i in range(num):
for j in range(i + 1):
print("*", end="")
print("")
# 乘法表
# 1*1=1
# 1*2=2 2*2=4
# 1*3=3 2*3=6 3*3=9
num = int(input("请输入乘法表边数(行跟列)"))
for i in range(num + 1):
for j in range(i + 1):
print("{}*{}={}".format(j + 1, i + 1, (j + 1) * (i + 1)), end=" ")
print("")
# 电脑随机一个0-100的数,将用户输入的跟电脑随机的数字对比,满分是100分,猜错口扣10分,分数为0,停止程序.
import random
score = 100
# randint(0,100) 包含0跟100
a = random.randint(0, 100)
count = 0
while True:
num = int(input("请输入第{}个:".format(count + 1)))
if num > a:
print("猜大了")
elif num < a:
print("猜小了")
else:
print("猜对了")
count += 1
if count == score / 10:
break
print("分已经全没,重启程序")
‘‘‘
猜数字游戏,电脑随机产生一个0-100的整数,用户在控制台输入一个整数,将用户输入的和电脑产生的进行对比:
如果用户猜大了,就提示猜大了,猜小了,就提示猜小了,猜对了就恭喜答对了
满分是100分，猜错一次就减10分，
当分数为0的时候，停止程序。
‘‘‘
import random
content = random.randint(0, 100)
count = 0
score = 100
while True:
if score == 0:
print("您的分数已经归为0,再见")
break
num = int(input("请输入第{}个数:".format(count + 1)))
if num > content:
print("您猜大了")
score -= 10
print("当前分数为:{}".format(score))
elif num < content:
print("您猜小了")
score -= 10
print("当前分数为:{}".format(score))
else:
print("恭喜你,猜对了,当前分数为:{}".format(score))
break
count += 1
‘‘‘
随机加减乘除运算,一共出10题,电脑随机产生2个0-100的整数,进行随机加减乘除法计算
然后用户输入计算结果,判断用户输入的是否正确,回答正确就加十分,错误就不加分,10题全对就是100分
‘‘‘
import random
score = 0
test = 0
sum = 0
while True:
if test == 10:
break
num1 = random.randint(0, 100)
num2 = random.randint(0, 100)
t = random.randint(0, 3)
if t == 0:
print("请回答第{}题:{}+{}=?".format((test + 1), num1, num2))
sum = num1 + num2
elif t == 1:
print("请回答第{}题:{}-{}=?".format((test + 1), num1, num2))
sum = num1 - num2
elif t == 2:
print("请回答第{}题:{}*{}=?".format((test + 1), num1, num2))
sum = num1 * num2
else:
print("请回答第{}题:{}//{}=?".format((test + 1), num1, num2))
sum = num1 // num2
user = int(input("请输入结果:"))
if user == sum:
score += 10
print("回答正确加10分,当前分数为:{}".format(score))
else:
print("回答错误减10分,当前分数为:{}".format(score))
print("当前总分为:{}".format(score))
test += 1
循环、列表等混合练习
‘‘‘
创建一个10个长度整数列表,列表中的10个元素,使用随机数赋值,范围0-100,然后找出列表中的最大值
‘‘‘
import random
list = []
for i in range(10):
list.append(random.randint(0, 100))
for j in range(len(list)):
max = list[0]
if max < list[j]:
max = list[j]
print(list[i], end=" ")
print("最大值为:{}".format(max))
# 冒泡排序
num = [51, 12, 55, 29, 18, 18, 18, 18, 55, 295, 5, 29]
for i in range(len(num)):
# 选出最大去掉一个
for j in range(len(num) - 1 - i):
if num[j] > num[j + 1]:
t = num[j]
num[j] = num[j + 1]
num[j + 1] = t
print(num)
‘‘‘
从26个字母中，随机选出4个不重复的字母
并且把4个字母，添加到一个列表中
用户在控制台输入4个字母，将用户输入的也添加到一个列表中
然后将电脑的和用户的 进行对比
‘‘‘
import random
# 从26个字母中，随机选出4个不重复的字母
def getChar():
c1 = [‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘, ‘f‘, ‘g‘, ‘h‘, ‘i‘, ‘j‘, ‘k‘, ‘l‘, ‘m‘, ‘n‘, ‘o‘, ‘p‘, ‘q‘, ‘r‘, ‘s‘, ‘t‘, ‘u‘, ‘v‘,
‘w‘, ‘x‘, ‘y‘, ‘z‘]
c2 = []
for i in range(4):
index = random.randint(0, len(c1) - 1)
c2.append(c1[index])
del c1[index]
print(c2)
return c2
# 检查用户输入是否正确的
def check(charList, user):
# 第一个下标保存猜对了几个，
# 第二个下标保存位置对了几个
result = [0, 0]
for i in range(len(charList)):
if user[i] in charList:
result[0] += 1
if user[i] == charList[i]:
result[1] += 1
print("猜对了{}个，位置对了{}个。".format(result[0], result[1]))
return result
print("猜字母游戏开始了。")
charList = getChar()
while True:
str = input("请输入四个字母,退出输入exit")
if str == "exit":
break
user = []
for s in range(4):
user.append(str[s])
print(user)
res = check(charList, user)
if res[1] == 4:
print("恭喜，全部猜对了")
break
print("游戏结束")
作用域
全局作用域
函数作用域
变量的查找 当使用变量时,会优先在当前作用域中寻找该变量,如果有则使用如果没有则继续去上一级作用域中寻找,如果有则使用,直到找到全局作用域,依然没有找到,则会抛出异常.
如果希望在函数内部修改全局变量,则需要使用global关键字,来声明变量,声明多个使用逗号隔开
# 全局变量
allIn=99
name="吴鹏"
age=24
def userInfo():
age=18
# 全局变量可以在函数中被访问，但是如果你想在函数中修改全局变量，那么就需要用 global进行修饰
global allIn,name
allIn+=1
name="吴磊"
print("姓名：{}，年龄：{}，allIn:{}".format(name,age,allIn))
def thanme():
print(allIn)
def show():
print("姓名：{}，年龄：{}，allIn:{}".format(name, age, allIn))
userInfo()
thanme()
show()
命名空间
字典
字典和列表类似,也是永爱保存一堆数据
语法:变量名={"键名1":"值1","键名2":"值2"}
需要注意的是键名也是要用引号包起来
字典中的键名是不能重复的
修改键值 变量名["键名"]="新键值"
删除键值对 del 变量名["键名"]
删除字典中的内容,不删除字段 变量名.clear()
直接删除整个字典 del 变量名
获取字典中所有的key与value 变量名.key() 变量名.value()
info={"name":"吴鹏","age":12}
# 获取其中的键值,需要使用get方法,如果不存在,将会返回none
print(info.get("name"))
# 也可使用采用类似于下标的方法得到键值,但是在使用变量赋的键名,不能使用引号
print(info["name"])
# 可以使用dict()函数创建字典
d=dict{"name":"吴磊","age":24}
# 修改键值
info["name"]="吴磊"
print(info.get("name"))
# 如果修改键值,该键名不存在,那么就是添加的操作
info["adress"]="南京市"
print(info)
# 使用setdefault()函数,可以向字典中添加键值对.如果说存在键,那么就会返回key的值,不会对字典做任何操作
info.setdefault("adress":"南京市")
# 使用update()函数,将其他字典添加到当前的字典中
a={"name":"abc",age=11}
b={{"adress":"南京",classes=11}}
# 将b中的键值对添加到a的字典中,如果有重复的,后面的会将前面的替换掉
a.update(b)
# 删除键值对
del info["adress"]
print(info)
# 使用popitem()函数,随机删除字典中的一个键值对,一般都会删除最后一个键值对,删除之后,会将删除的key-value作为返回值返回,返回的是一个元素,第一个元素是删除的key,第二个删除的是value
print(info.popitem())
# 删除字典中的内容,不删除字典
# info.clear()
# print(info)
# 直接删除整个字典
# del info
print(info.keys())
print(info.values())
# copy()函数,复制,好处就是复制以后的对象和源对象是独立的,修改一个不会影响另一个
d1={"name":"ad","age":10}
d2=d1.copy()
# 获取字典键值对的个数
print(len(info))
# in检查字典中是否包含指定的键
# not in 检查字典中是否不包含指定的键
#遍历字典
for k in d.keys():
print(k,d[k])
文件操作
文件操作的语法 变量名=open("文件名称",打开方式,定义字符集)
每操作一次文件,必须要关闭 变量.close()
判断文件是否是关闭 变量.closed
写入内容 变量.write()
读取文件内容 变量.read()
文件改名,需要引入模块os os.rename("原始文件名","新文件名")
删除文件 同样需要引入模块 os.remove("文件名")
‘‘‘
文件操作
f = open(‘文件名称‘,‘打开方式‘)
r : 读取，
w ：写入，创建，覆盖
a ： 写入，创建，追加
‘‘‘
f = open(‘a.txt‘,‘w‘)
# 获取文件名称
print(f.name)
# 获取打开方式
print(f.mode)
# 判断文件是否关闭，关闭True， 没有关闭false
print(f.closed)
# close()函数，是用来关闭文件, 文件打开使用完之后，一定要记得关闭
f.close()
print(f.closed)
f = open("a.txt","w")
# write()写入字符串
f.write("1234567890")
# 操作完要记得关闭
f.close()
f = open("a.txt","w")
f.write("我的贱就是你的贱")
f.close()
f = open("a.txt","w",encoding=‘utf-8‘)
f.write("good good")
f.close()
# 追加内容操作
f = open("a.txt","a",encoding=‘utf-8‘)
f.write("艾斯帝王企鹅")
f.close()
f = open("a.txt","a",encoding=‘utf-8‘)
f.write("\n")
f.write("面朝大海，春暖花开")
f.close()
# 读取文件内容
f = open("a.txt",‘r‘,encoding=‘utf-8‘)
s1 = f.read()
# 要记得关闭文件
f.close()
# 改名操作需要引入模块
import os
# os.rename("a.txt","b.txt")
# 删除文件，remove()
os.remove("a.txt")
# 在with语句中可以直接使用对象来做文件操作
with open("a.txt",‘r‘,encoding=‘utf-8‘) as f:
#此时文件只能在with中使用,一旦with结束则文件会自动close()
print(f.read())
# 读取文件中的一行内容
with open(‘a.txy‘,encoding=‘utf-8‘) as f:
print(f.readline())
# readlines()这个方法用于一行一行的读取内容,它会一次性将读取到的内容封装到一个列表中返回
# 使用with as写入文件
with open(‘a.txt‘,‘w‘,encoding=‘utf-8‘) as f:
f.write(‘youname‘)
# r表示只读
# w表示可写
# a表示追加
# +表示操作符增加功能
# x用来新建文件,如果文件包不存在则创建,存在则报错
# r+表示可读与可写,文件不存在会报错
# seek()方法可以修改当前读取的位置 f.seek()
# tell()方法用来查看当前读取的位置 f.tell()
对象
每个对象都要保存三种数据 id type value
对象在python中,变量中存储的不是对象的值,而是对象的id(内存地址),当我们使用变量时,实际上就是通过对象id在查找对象.
==和is
文档字符串
help() 是python中的内置函数,通过help()函数可以查询python中函数的用法
文档字符串只需要在函数的第一行写一个字符串就是文档字符串,该字符串使用‘‘‘引一下,最终使用help()函数传入函数名
def fn(a:int,b:bool):
‘‘‘
这是一个文档声明
a的作用传入int类型的值
b的作用传入一个bool类型的值
‘‘‘
help(fn)
递归
简单的理解递归,就是循环自己一直,自己引用自己.
递归式函数的两个条件:
# 求10的阶乘(1*2*3*4*5*...*10)
# 10!=10*9!
# 9!=9*8!
# 8!=8*7!
# ...
# 1!=1
def factorial(n):
# 该函数用来求任意数的阶乘
# 基线条件,判断n是否为1,如果为1则此时不能再继续进行递归
if n==1:
# 1的阶乘就是1,直接返回1
return 1
return n*factorial(n-1)
print(factorial())
递归的练习
# 创建一个函数 power 来为任意数字做幂运算 n ** i
# 10 ** 5 = 10 * 10 ** 4
# 10 ** 4 = 10 * 10 ** 3
# ...
# 10 ** 1 = 10
def power(n , i):
‘‘‘
power()用来为任意的数字做幂运算
参数：
n 要做幂运算的数字
i 做幂运算的次数
‘‘‘
# 基线条件
if i == 1:
# 求1次幂
return n
# 递归条件
return n * power(n , i-1)
# print(power(8,6))
# 检查指定的字符串是不是回文字符串
def hui_wen(s):
‘‘‘
该函数用来检查指定的字符串是否回文字符串，如果是返回True，否则返回False
参数：
s：就是要检查的字符串
‘‘‘
# 基线条件
if len(s) < 2 :
# 字符串的长度小于2，则字符串一定是回文
return True
elif s[0] != s[-1]:
# 第一个字符和最后一个字符不相等，不是回文字符串
return False
# 递归条件
return hui_wen(s[1:-1])
print(hui_wen(‘abcdefgfedcba‘))
函数式编程 在python中,函数时一等对象,有如下几个特点:
能赋值给变量或作为数据结构中的元素
能作为返回值返回
高阶函数 至少符合以下两个特点中的一个:
匿名函数
lambda函数表达式专门用来创建一些简单的函数,他是函数创建的又一种方式
匿名函数一般都是作为参数使用,其他地方一般不会使用
语法:lambda 参数列表 : 返回值
def fn(a,b):
return a+b
# 等同于如下的匿名函数
fn2=lambda a,b : a + b # 一般不会这么做
map()函数可以滴可迭代对象中的所有元素做指定的操作,然后将其添加到一个新的对象中返回
l=[1,2,3,4,5]
r=map(lambda i:i+1,l)
print(list(r))
sort()函数
该方法用来对列表中的元素进行排序
sort方法默认是直接比较列表中元素的大小
在sort()可以接受一个关键字参数key,它需要一个函数作为参数,当设置了函数作为参数,每次都会以列表中的一个元素作为参数来调用函数,并且使用函数的返回值来比较元素的大小
# 字符串默认按照unicode编码排序
l=["a","b","cc","aa"]
# 使用key=len是按照字符串的长度排序
l.sort(key=len)
print(l)
# 直接排序会报错
m=[1,2,"3",2,"3"]
# 使用key=int 会暂时转化为int类型排序
m.sort(key=int)
print(m)
sorted()
装饰器
希望函数可以在计算前,打印开始计算,计算结束后打印计算完毕
可以直接通过修改函数满足需求,但产生如下的问题:
类
创建类 class 类名:(正常情况下类名需要大写)
在类中我们所定义的变量,将会成为所有实例的公共属性,所有实例都可以访问这些变量
在类中也可以定义函数,类中定义的函数,我们称为方法.这些方法可以通过该类的所有实例来访问
init()函数 在创建一个对象完成时,会自动被调用一般用来初始化对象,self,不需要开发者传递,python解释器会自动把当前对象的引用传递进去.
# 创建一个persion类,类可以有属性,有函数
class Person():
name="吴鹏"
age=18
#创建实例对象所传入的参数会跟init有关
# 在使用init的时候,每次创建一个实例对象就会调用一次
def __init__(self,name,age):
print("我的姓名是:{},我的年龄是:{}".format(name,age))
def info(self,name,age):
print("我的姓名是:{},我的年龄是:{}".format(name,age))
# 创建对象,wp是Person的实例
wp=Person("吴娟",18)
# 调用的时类中的属性
print(wp.name)
# 调用类中的函数,函数后传入了形参,与之对应会有实参
wp.info("吴磊",18)
# 检查一个对象是否是一个类的实例,如果是就是true,如果不是则是false
result=isinstance(wp,Person);
print(result)
在类中创建的方法中会默认添加一个参数,使用pychar系统会给一个self作为参数传递进去
属性和方法
当我们调用一个对象的属性时,解析器会现在当前对象中寻找是否含有该属性,如果有则直接返回当前对象的属性值,如果没有,则去当前对象的类对象中去寻找,如果有则返回类对象的属性值,如果没有则报错
类对象和实例对象中都可以保存属性和方法
类属性,直接在类中定义的属性是雷属性,类属性可以通过类或类的实例访问到,但是类属性只能通过类对象来修改,无法通过实例对象修改.
实例属性,通过实例对象添加的属性属于实例属性,实例属性只能通过实例对象来访问和修改,类对象无法访问修改
实例方法可以通过实例和类去调用,当通过实例调用时,会自动将当前调用对象作为self传入,当通过类调用时,不会自动传递self,此时需要手动传递self
在类内部使用@classmethod来修饰的方法属于类方法,类方法的第一个参数是cls,也会被自动传递,cls就是当前的类对象,类方法可以通过类去调用,也可以通过实例调用,没有区别
在类中使用@staticmethod来修饰的方法属于静态方法,静态方法不需要指定任何的默认参数,静态方法可以通过类和实例去调用,静态方法基本上是一个和当前类无关的方法.它只是一个保存到当前类中的函数,静态方法一般存放的都是一些工具方法
类的特殊方法
在类中可以定义一些特殊方法(魔术方法)
特殊方法都是以__ 开头,__ 结尾的方法
特殊方法不需要我们自己调用,不要去尝试调用特殊方法.特殊方法会在特殊的时刻自动调用
当我们打印一个对象时,实际上打印的是对象中的特殊方法__ str__()的返回值,作用就是制定对象转换为字符串的结果.
__ repr __() 这个特殊方法会在对当前对象使用repr()函数时调用
__ len __ () 获取对象的长度
__ bool __() 返回对象的bool类型
object.__ lt __ (self,other) 小于
object.__ le __ (self,other) 小于等于
object.__ eq __ (self,other) 等于
object.__ ne __ (self,other) 不等于
object.__ gt __ (self,other) 大于
object.__ ge __ (self,other) 大于等于
class Person:
# 魔术方法比较对象
def __init__(self,name,age):
self.name=name
self.age=age
def __lt__(self, other):
return self.age>other.age
p1=Person("吴鹏",18)
p2=Person("吴磊",20)
print(p1.age>p2.age)
__ init __可以在新创建的对象中初始化属性
class Person():
name="吴鹏"
age=18
def __init__(self,name,age):
self.name=name
self.age=age
def info(self):
print("我叫:{},今年:{}" .format(self.name,self.age))
wp=Person("吴鹏",18)
wp.info()
创建对象的流程
封装 (确保对象中的数据安全)
隐藏对象中一些不希望被外部所访问到的属性或方法
如何隐藏一个对象中的属性?
如何获取(修改)对象中的属性
property装饰器
class Person:
def __init__(self, name):
self.name = name
# property装饰器,用来将一个get方法,转换为对象的属性
# 添加为property装饰器后,我们就可以像调用属性一样使用get方法
@property
def get_name(self):
return self.name
# 指定setter方法的装饰器 @属性名.setter
@get_name.setter
def get_name(self,name):
self.name=name
p = Person("吴磊")
print(isinstance(obj,p))
print(p.get_name)
继承 (保证了对象的扩展性)
通过继承可以使一个类获取到其他类中的属性和方法
在定义类的时候,可以在类名后的括号中指定当前类的父类(超类),子类可以直接继承父类中的所有的属性和方法
通过继承可以直接让子类获取到父类的方法或属性,避免编写重复性的代码,并且也符合ocp原则,所以我们经常需要通过继承来对一个类进行扩展
在创建类时,如果省略了父类,则默认父类为object,object是所有类的父类,所有类都继承自object,所有的对象都是object的实例
多重继承
重写
多态 (保证了程序的灵活性)
模块化
采用模块化,统一将所有的代码编写到一个文件中
优点:方便开发,方便维护,模块可以复用.
import语句一般引用在程序的开头位置
在一个模块中引入外部模块
在每一个模块内部都有一个__ name __属性,通过这个属性可以获取到模块的名字
访问模块中的变量:模块名.变量名
也可以引入模块中的部分内容
编写测试代码,有些代码在当前文件作为主模块的时候才需要执行,而当模块被其他模块引入时,不需要执行,此时我们就必须要检查当前模块是否是主模块
if __name__=="__main__":
test() # 调用方法
包
python的标准库
标准库会随python的安装一同安装
sys模块
os模块
pprint模块
异常
程序运行时出现异常,目的并不是让我们的程序直接终止!python是希望在出现异常时,可以编写代码来对异常进行处理.
异常的处理语法:
try 语句
try :
代码块(可能出现错误的语句)
except:
代码块(出现错误以后的代码)
finally:
else:
代码块(没出错时要执行的语句)
可以将可能出错的代码放到try语句,这样如果代码没有错误,则会正常执行,如果出现错误,则会执行expect子句中的代码,这样我们就可以通过代码来处理异常,避免因为一个异常导致整个程序的终止.
异常的传播
当在函数中出现异常时,如果在函数中对异常进行了处理,则异常不会再继续传播,.
如果函数中没有对异常进行处理,则异常会继续向函数调用处传播
如果函数调用处处理了异常,则不再传播,如果没有处理则继续像调用处传播,知道传递到全局作用域(主模块)如果依然没有处理,则程序终止,并且显示异常信息
当程序运行过程中出现异常以后,所有的异常信息会被保存到一个专门的异常对象中,而异常传播时,实际上就是异常对象抛给了调用处
如果except后不跟任何的内容,那么此时会补货到所有的异常
如果except后跟着一个异常的类型,那么此时只会捕获该类型的异常 except NameError:
Exception是所有异常类的父类,所以如果except后跟的是Exception他也会捕获到所有的异常
可以在异常类后面跟一个as xx此时的xx就是异常对象
finally是无论是否出现异常,该子句都会执行.
print(‘异常出现前‘)
l=[]
try:
print(c)
l[10]
print(10/0)
except NameError:
print(‘出现NameError异常‘)
except ZeroDivisionError as zde:
print(‘出现ZeroDivisionError异常‘,zde)
except:
print(‘未知异常‘)
print(‘异常出现后‘)
抛出异常
可以使用raise语句来抛出异常,raise语句后需要跟一个异常类或异常的实例
def add(a,b):
if a<0 or b<0:
raise Exception("a跟b不能为负值")
return a+b
add(-1,20)
抛出异常的目的就是,告诉调用者这里调用时出现问题,希望你自己处理一下.
自定义异常 class MyError(Exception): 然后调用的时候直接调用MyError就可
标签：lists 参数表 sts date for 运行时 精确 去除 没有
原文地址：https://www.cnblogs.com/wp950416/p/12191228.html
