TempStr = input("请输入带有符号的温度值: ")
if TempStr[-1] in ['F','f']:
C = (eval(TempStr[0:-1]) - 32)/1.8
print("转换后的温度是{:.2f}C".format(C))
elif TempStr[-1] in ['C','c']:
F = 1.8*eval(TempStr[0:-1]) + 32
print("转换后的温度是{:.2f}F".format(F))
else:
print("输入格式错误")
Python 语言允许采用大写字母、小写字母、数字、
组合给变量命名,但名字的首字符不能是数字,中间不空格,长度无限制。
注意:标识符,保留字对大小写敏感:python3中可以采用中文等非英语语言字符对变量命名
33个保留字列表
字符串包括:正向递增系列和反向递减系列
input(<提示性文字>)函数从控制台获得用户输入,并输出带提示性文字
无论用户输出字符还是数字,input()统一以字符串型输出
类型: if-elif-else
例:
if s[-1] in ['F','f''] :
<语句块1>
elif <条件2>:
<语句块2>
else:
<语句块3>
列表: [元素1, ... ,元素n]
例如:
>>>s="102C"
>>>eval(s[0:-1])
102
输入"‘hello’"时,eval()去掉最外层引号后.结果为字符串’hello’
输入数字运算时,可搭配input()使用
>>>s=eval(input("请输入一个数字: "))
请输入一个数字: 10024.256
>>>print(s*2)
2048.512
纯信息输出时 print(<带输出字符串>)
格式化输出时 print()函数用槽格式,通过format()函数将输出变量格式化输出
>>>c=10
>>>print("转换后温度为{:.2f}C".format(c))
转换后温度为10.00C
TempStr = input("请输入带有符号的温度值: ")
while TempStr[-1] not in ['N','n']:
if TempStr[-1] in ['F','f']:
C = (eval(TempStr[0:-1]) - 32)/1.8
print("转换后的温度是{:.2f}C".format(C))
elif TempStr[-1] in ['C','c']:
F = 1.8*eval(TempStr[0:-1]) + 32
print("转换后的温度是{:.2f}F".format(F))
else:
print("输入格式错误")
TempStr = input("请输入带有符号的温度值: ")
定义一个 temp(ch)函数
def temp(ch):
c=ch+2
retun c
主函数写法 if __name__ == '__main__':
import turtle
turtle.setup(650, 350, 200, 200)
turtle.penup()
turtle.fd(-250)
turtle.pendown()
turtle.pensize(25)
turtle.pencolor("purple")
turtle.seth(-40)
for i in range(4):
turtle.circle(40, 80)
turtle.circle(-40, 80)
turtle.circle(40, 80/2)
turtle.fd(40)
turtle.circle(16, 180)
turtle.fd(40 * 2/3)
turtle.penup()
别名: turtle.pu() , turtle up()
作用:抬起画笔,之后移动不绘制形状
turtle.pendown()
别名:turtle.pd() ,turtle.down()
作用:落下画笔,运动会绘制形状(与turtle.penup()一组)
turtle.pensize(width)
别名: turtle.width()
作用:设置画笔尺寸
参数:width画笔的宽度,如果为None或空,则返回当前画笔宽度
turtle.pencoclor(colorstring)或turtle.pencolor((r,g,b))
作用:设置画笔颜色,无参数时返回当前画笔颜色
参数:colorstring 表示颜色字符串,如"purple",“red”,“blue”
(r,g,b)颜色对应的RGB数值,如(51,204,140)
turtle.forward(d)
别名:turtle.fd(d)
作用:向当前行进方向前进 d距离
参数:d行进距离的像素值,当值为负数时,向相反方向前进
turtle.bk(d)
作用:向海龟 负方向移动 d距离 (海龟方向不改变)
turtle.setheading(angle)
别名:turtle.seth(angle)
作用:设置海龟当前前进方向angle,该角度为绝对方向角度
参数:angle行进方向的绝对角度的整数值
turtle.left(angle)
作用:海龟向左转
参数:angle在海龟当前行进方向上旋转的角度
. turtle.right(angle)
作用:海龟向右转
参数:angle在海龟当前行进方向上旋转的角度
turtle.circle(r,extent=None)
作用:根据半径r绘制extent角度的弧形
参数:r半径,当值为正数时,半径在海龟左侧:但值为负数时,半径在海龟右侧.
extent,绘制弧形的角度,但不设参数或设置为None时,绘制整个圆
turtle.done()
作用:绘图完后手动退出,若不加,则程序完成就自动退出(一般都在绘图程序后加此函数)
turtle.speed()
设置画笔速度(0-10),速度越大越快,大于10小于0.5时默认为0,0是最快的速度
turtle.undo()
撤销上一次命令
.hideturtle()
隐藏海龟
turtle.showturtle()
显示海龟
格式:
for i in range(<循环次数>):
<语句块>
range(n) 产生0至n-1的整数系列,共循环n次
range(n,m)产生n至m-1的整数系列,共循环m-n次
整数类型包括:十进制、二进制、八进制、十六进制
pow(x,y),计算x^y (x的y次方)
表示方法:十进制和科学计数法
科学计数法:以字母e或E 作为幂的符号,以10为基数,e=a*10^b
例如:4.3e-3=0.0043
复数的虚部以后缀 “j"或"J” 表示
其实部与虚部的数值都是浮点数
z.real 获取z的实部
z.imag或缺z的虚部
3种数字类型的扩展关系: 整数->浮点数->复数
不同数字类型间运算所生成结果是"更宽"的类型
例如:整数浮点数与分数运算,结果为分数
函数 | 描述 |
---|---|
abs(x) | x的绝对值,例如`>>>abs(-3+4j) 结果为5.0 |
divmod(x,y) | (x//y,x%y) ,输出为二元组形式(元组类型) |
pow(x,y[z]) | (xy)%z,[…]表示该参数可以省略,即pow(x,y),等价于xy |
round(x[,d]) | 对x四舍五入,保留d位小数,round(x)返回四舍五入的整数 |
max(x1,x2,…,xn) | x1,x2,…xn的最大值,n无限定 |
min(x1,x2,…,xn) | x1,x2,…xn的最小值,n无限定 |
函数 | 描述 |
---|---|
int(x) | 将x转换为整数,x可以为浮点数(直接舍弃小数部分,不四舍五入)或字符串 |
float(x) | 返回浮点数x或字符串x对应的整数类型 |
complex(re[,im] | 生成一个复数,re为实部,可以是整数.浮点数或字符串:im为虚部,可以是整数浮点数不能为字符串 |
复数不能直接转换为其他数字类型,可以通过.real和.imag提取实部和虚部,然后分别转换
例如:
>>>float((10+99j).imag)
99.0
【实例代码3.3】天天向上。
一年365天,如果好好学习时能力值相比前一天提高1%,当放任时相比前一中国人 天下降1%。效果相差多少呢?
此时,天天向上的力量是(1+0.01)365,相反的力量是(1-0.01)365。从0.001、0.005到0.01,这个每天努力的因素根据需求的不同而不断变化,因此,新代码中采用dayfactor变量表示这个值。这种改变的好处是每次只需要修改这个变量值即可,而不需要修改后续与该变量相关位置的代码。代码如下:
import math
dayfactor = 0.01
dayup = math.pow((1.0 + dayfactor), 365) # 提高dayfactor
daydown = math.pow((1.0 - dayfactor), 365) # 放任dayfactor
print("向上: {:.2f}, 向下: {:.2f}.".format(dayup, daydown))
【实例代码3.5】天天向上。
每周工作5天,休息2天,休息日水平下降0.01,工作日要努力到什么程度,一年后的水平才与每天努力1%取得的效果一样呢?
代码如下:
#e3.5DayDayUp365.py
def dayUP(df):
dayup = 1.0
for i in range(365):
if i % 7 in [6, 0]:
dayup = dayup * (1 - 0.01)
else:
dayup = dayup * (1 + df)
return dayup
dayfactor = 0.01
while (dayUP(dayfactor)<37.78):
dayfactor += 0.001
print("每天的努力参数是: %.3f."%dayfactor)
操作符 | 描述 |
---|---|
x+y | 连接两个字符串x和y |
x*n或n*x | 复制n次字符串x |
x in s | 如果x是s的子串,返回True,否则返回False |
str[i[ | 索引,返回第i个字符串 |
str[N:M] | 切片,返回索引第N到第M-1的子串 |
字符 | 含义 |
---|---|
\n | 换行 |
\\ | 表示反斜杠\ |
\’ | 表示单引号’ |
\" | 表示双引号" |
\t | 水平制表(Tab) |
\a | 蜂鸣,响铃 |
\b | 回退,向后退一格 (py文件下) |
\f | 换页 |
\n | 换行,光标移动到下行首行 |
\r | 回车,光标移动到本行首行(py文件下) |
\v | 垂直制表 |
\0 | NULL,什么都不做 |
python3以Unicode字符为计数基础,字符串中英文字符和中文字符都是一个长度单位
函数 | 描述 |
---|---|
len(x) | 返回字符串x的长度,也可以返回其他组合数据类型元素个数 |
str(x) | 返回任意类型x对应的字符串形式 |
chr(x) | 返回Unicode编码x对应的单字符 |
ord(x) | 返回单字符对应的Unicode编码 |
hex(x) | 返回整数x对应十六进制数的小写形式字符串 |
oct(x) | 返回整数x对应八进制数的小写形式字符串 |
信息中每一个英文字符循环替换为字母表顺序中该字符后面第三个字符
plaincode = input("请输入明文: ")
for p in plaincode:
if ord("a") <= ord(p) <= ord("z"):
print(chr(ord("a") + (ord(p) - ord("a") + 3)%26),end='')
else:
print(p, end='')
str为字符串或变量
方法 | 描述 |
---|---|
str.lower() | 返回字符串str的副本,全部字符小写 |
str.upperr() | 返回字符串str的副本,全部字符大写 |
str.islower() | 当str所有字符都是小写时,返回True,否则返回False |
str.isprintable() | 当str所有字符都是可打印的,返回True,否则返回False |
str.isnumeric() | 当str所有字符都是数字时,返回True,否则返回False |
str.isspace() | 当str所有字符为空格时,返回True,否则返回False |
str.endswith(suffix[,start[,end]]) | str[start:end]以suffix结尾返回True,否则返回False |
str.srartswith(prefix[,start[,end]]) | str[start:end]以prefix开始返回True,否则返回False |
str.split(sep=None,maxsplit=-1) | 返回一个列表,由str根据sep被分隔的部分构成,默认分隔符为空格,maxsplit为最大分隔次数,默认maxsplit参数可以不给出 |
str.count(sub[,start[,end]]) | 返回str[start:end]中sub子串出现的次数 |
str.replace(old,new[,count]) | 返回字符串str的副本,所有old子串被替换为new,如果count给出,则前count次old出现被替换 |
str.center(width[,fillchar]) | 字符串居中函数,返回长度为width的字符串,其中str处于新字符串中心位置,两侧增加字符采用fillchar填充,当witdh小于字符串长度时,返回str |
str.strip([chars) | 返回字符串str的副本,在其左右侧去掉chars中列出的字符 |
str.zfill(width) | 返回长度为width的字符串,如果字符串长度不足width,在左侧添加字符“0”,但如果str最左侧是字符”+”或者”-”,则从第二个字符左侧添加”0”,当width小于字符串长度时,返回str。该方法主要用于格式化数字形字符串中 |
str.format() | 返回字符串str的一种排版格式 |
str.join(x) | 返回一个新字符串,由组合数据类型x变量的每一个元素组成,元素间用str分隔 |
格式:<模板字符串>.format(<逗号分隔的参数>)
format()中逗号分隔的参数按照 序号关系替换到模板字符串的槽中,槽用{}表示,如果槽中没有序号,则按照顺序替换
如果`需要输出大括号,采用{{{表示,}}表示}
>>>"圆周率{{{1}{2}}}是{0}",format("无理数",3.14,"...")
'圆周率{3.14...}是无理数'
import time
scale = 20
print()
print("------执行开始------")
for i in range(scale+1):
a, b = '**' * i,'..' * (scale - i)
c = (i/scale)*100
print("%{:^3.0f}[{}->{}]" .format (c, a, b))
time.sleep(0.1)
print("------执行结束------")
import time
scale = 50
print("执行开始".center(scale // 2,"-"))
start = time.perf_counter()
for i in range(scale + 1):
a = "*" * i
b = "." * (scale - i)
c = (i / scale) * 100
dur = time.perf_counter() - start
print("\r{:^3.0f}%[{}->{}]{:.2f}s".format(c,a,b,dur),end = "")
time.sleep(0.1)
print("\n"+"执行结束".center(scale // 2,"-"))
import time
def pace():
for i in range(1, 101):
print("\r", end="")
print("下载进度: {}%: ".format(i), "▋" * (i // 2), end="")
time.sleep(0.1)
pace()
from time import sleep
from tqdm import tqdm
# tqdm 进度条库
for i in tqdm(range(1,1001)):
# 模拟你的任务
sleep(0.01)
import PySimpleGUI as sg
import time
mylist = [1,2,3,4,5,6,7,8,9,10]
for i, item in enumerate(mylist):
sg.one_line_progress_meter('进度', i+1, len(mylist), '-key-')
time.sleep(1)
程序基本结构组成: 顺序结构,分支结构和循环结构
python的关系操作符
操作符 | 含义 |
---|---|
< | 小于 |
<= | 小于或等于 |
>= | 大于或等于 |
> | 大于 |
== | 等于 |
!= | 不等于 |
注意:
1.使用’=‘表示赋值语句,使用’==’ 表示等于
2. 字符串比较依次按照字典顺序进行,英文大写字符对于unicode编码比小写字符小
>>>"Python" > "python"
False
格式:
if <条件>:
<语句>
格式1:
if <条件>:
<语句1>
else:
<语句2>
格式2:紧凑结构
<表达式1> if <条件> else <表达式2>
#表达式1,2 一般是数字类型或字符串类型中的一个值
if <条件1>:
<语句1>
elif <条件2>:
<语句2>
else:
<语句3>
#elif 可以多个
格式:
for <循环变量> in <遍历结构>:
<语句>
遍历结构可以是 字符串,文件,组合数字类型或range()函数 等
# 循环n次
for i in range(n):
# 遍历文件fi的每一行
for line in fi :
# 遍历字符串s
for c in s:
# 遍历列表ls
for ltem inls:
while <条件>:
<语句>
#其中 条件与if 中判断条件一样,结果为 True或False
break : 跳出最内层for或while循环
continue : 结束当前当次循环,继续循环条件中的未执行语句
for <循环变量> in <遍历结构>:
<语句>
else:
<语句2>
while <条件>:
<语句>
else :
<语句2>
for循环和while循环中都存在一个else扩展用法。else中的语句块只在一种条
件下执行,即循环正常遍历了所有内容或由于条件不成立而结束循环,没有因为
break 或returm(函数返回中使用的保留字)而退出。
continue保留字对else 没有影响
函数 | 描述 |
---|---|
seed(a=None | 初始化随机数种子,默认值为当前系统数据 |
random() | 生成一个[0.0,1.0]之间的随机小数 |
randint(a,b) | 生成[a,b]之间的整数 |
getrandbits(k) | 生成一个k比特长度的随机整数 |
randdrange(start,stop[,step] | 生成一个[start,stop]之间以step为步数的随机整数 |
uniform(a,b) | 生成[a,b]之间的随机小数 |
choice(seq) | 以序列类型,例如列表中随机返回一个元素 |
shuffle(seq) | 将序列列表中的元素随机排列,返回打乱后的序列 |
sample(pop,k) | 从pop类型中随机选取k个元素,以列表类型返回 |
from random import random
from math import sqrt
from time import clock
DARTS = 1000
hits = 0.0
clock()
for i in range(1, DARTS+1):
x, y = random(), random()
dist = sqrt(x ** 2 + y ** 2)
if dist <= 1.0:
hits = hits + 1
pi = 4 * (hits/DARTS)
print("Pi值是{}.".format(pi))
print("运行时间是: {:5.5}s".format(clock()))
格式1:
try :
<语句1>
except:
<语句2>
语句1的正常执行的程序内容,当发生异常时执行except后面的语句
格式2: 异常高级用法 支持多个except
try :
<语句1>
except <异常类型1>:
<语句2>
except <异常类型N>:
<语句N+1>
except :
<语句N+2>
异常语句还能与else和 finally 保留字 配合使用
try :
<语句1>
except:
<语句2>
else :
<语句3>
finally :
<语句4>
else: 当try的语句1正常执行结束且没有发生异常时,else中语句3运行
finally: 无论try语句1是否异常,语句4都执行
def happy():
print("happy")
def happy():
print("happy")
happy()
x = lambda a, b : a * b
print(x(5, 6))
>30
type(x)
>
>>> func(x1,x2,x3,x4)
#位置传参
>>>result = func(1,2,3,4)
#名称传参:
>>> result = func( x1=1,x3=3,x2=2,x4=4)
1.局部变量可以与全局变量重名,但函数内局部变量不改变全局变量的值
total = 0 # 这是一个全局变量
def sum( arg1, arg2 ):
total = arg1 + arg2 # total在这里是局部变量.
print ("函数内是局部变量 : ", total)
# 这里输出的是30
return total
sum( 10, 20 )
print ("函数外是全局变量 : ", total)
# 输出全局变量 0
def myfunc():
global x
x = 100
myfunc()
print(x)
>100
3.组合数据类型的全局变量 (列表字典),如果在函数内部没有被真实创建的同名变量,则函数内部可以中间使用并修改全局变量的值, 如果函数内部存在同名真实创建的列表,则函数使用该列表不会改变全局变量
ls = []
def f( a ,b ):
li.append(b) #将局部变量b增加到全局变量ls中
return a*b
s = f ( "kno~",2)
print( s ,ls)
#输出 kno~kno~ [2]
ls = [ ]#全局变量ls
def f( a ,b ):
ls = [] #同名的局部变量 ls
li.append(b) #将局部变量b增加到局部变量ls中
return a*b
s = f ( "kno~",2)
print( s ,ls)
# 输出 kno~kno~ []
类 | 表示含义 |
---|---|
datatime.date | 表示日期的类,可以表示 年 月 日 |
datatime.time | 表示时间的类,可以表示 小时 分钟 秒 毫秒 |
datatime.datetime | 表示时间日期的类,覆盖上面两种 |
datatime.timedelta | 表示两个datetime对象的差值; |
datatime.tzinfo | 表示时区的相关信息 |
创建datatime对象的三种方法datetime.now(),datetime.utcnow(),datetime.datetime().
1.datatime.now() 获取当前的日期和时间对象,返回datatime.datatime类型,
2.datatime.utchow ()获取当前日期和时间对应的UTC时间,返回datatime类型
3.datatime()构造一个日期时间对象
方法 datatime(year,moth,day,hour=0,minute=0,second=0,microsecond=0)
>>> from datetime import datetime
>>> today= datetime.now() #返回一个datetime类型,表示当前日期和时间,精确到微秒。
>>> today
datetime.datetime(2020, 9, 19, 9, 46, 35, 391262)
>>> today= datetime.utcnow() #返回一个datetime类型,表示当前日期和时间的UTC(世界标准时间)表示,精确到微秒。
>>> today
datetime.datetime(2020, 9, 19, 1, 48, 53, 506101)
>>> today = datatime(2020, 9, 19, 1, 48, 53, 506101)
datetime.datetime(2020, 9, 19, 1, 48, 53, 506101)
datatime类常用的属性,创建today为datetime对象:
属性 | 描述 |
---|---|
today.min | 固定返回datetime的最小时间对象,datetime(1,1,1,0,0) |
today.max | 固定返回datetime的最大时间对象,datetime(9999.12,31,23l,59,59,999999) |
today.year | 返回today包含的年份 |
today.month | 返回today包含的月份 |
today.day | 返回today包含的日期 |
today.hour | 返回today包含的小时 |
today.minute | 返回today包含的分钟 |
today.second | 返回today包含的分秒 |
today.microsecond | 返回today包含的微秒值 |
datatime 对象常用的时间格式化方法:
属性 | 描述 |
---|---|
today.isoformat() | 采用ISO标准显示时间。 |
today.isoweekday() | 根据日期计算星期后返回1—-7对应星期一到星期日。 |
today.strtime(format) | 根据格式化字符串format进行格式显示的方法 |
使用方法如下 |
today= datetime(2020,9,19,10,0,35,397865)
today.isoformat() #运行结果:'2020-09-19T10:00:35.397865'
today.isoweekday() #运行结果:6
today.strftime("%Y-%m-%d %H:%M:%S")#运行结果'2020-09-19 10:00:35'
strtime()格式化字符串的数字左侧会自动补零
strftime()方法的格式化控制符表:
格式化字符串 | 日期/时间 |
---|---|
%Y | 年份 (0001-9999 ) |
%m | 月份( 01-12) |
%B | 月名 (January-December) |
%b | 月名缩写 (Jan-Dec) |
%d | 日期 (01-31) |
%A | 星期(Monday-Sunday) |
%a | 星期缩写(Mon-Sun) |
%H | 小时(24小时制)(00-23) |
%M | 分钟(00-59) |
%S | 秒(00-59) |
%x | 日期(年/月/日) |
%X | 时间(时: 分 :秒) |
import turtle, datetime
def drawGap(): #绘制数码管间隔
turtle.penup()
turtle.fd(5)
def drawLine(draw): #绘制单段数码管
drawGap()
turtle.pendown() if draw else turtle.penup()
turtle.fd(40)
drawGap()
turtle.right(90)
def drawDigit(d): #根据数字绘制七段数码管
drawLine(True) if d in [2,3,4,5,6,8,9] else drawLine(False)
drawLine(True) if d in [0,1,3,4,5,6,7,8,9] else drawLine(False)
drawLine(True) if d in [0,2,3,5,6,8,9] else drawLine(False)
drawLine(True) if d in [0,2,6,8] else drawLine(False)
turtle.left(90)
drawLine(True) if d in [0,4,5,6,8,9] else drawLine(False)
drawLine(True) if d in [0,2,3,5,6,7,8,9] else drawLine(False)
drawLine(True) if d in [0,1,2,3,4,7,8,9] else drawLine(False)
turtle.left(180)
turtle.penup()
turtle.fd(20)
def drawDate(date):
turtle.pencolor("red")
for i in date:
if i == '-':
turtle.write('年',font=("Arial", 18, "normal"))
turtle.pencolor("green")
turtle.fd(40)
elif i == '=':
turtle.write('月',font=("Arial", 18, "normal"))
turtle.pencolor("blue")
turtle.fd(40)
elif i == '+':
turtle.write('日',font=("Arial", 18, "normal"))
else:
drawDigit(eval(i))
def main():
turtle.setup(800, 350, 200, 200)
turtle.penup()
turtle.fd(-350)
turtle.pensize(5)
drawDate(datetime.datetime.now().strftime('%Y-%m=%d+'))
turtle.hideturtle()
main()
基本要求:
1.紧耦合: 功能块内部耦合紧密
2.松耦合: 功能块之间耦合度底
使用递归一定要有基例的构建,可以多个基例,基例决定递归的深度
默认情况调用1000层,python解释器终止程序,
若需要超过1000层,可用下面代码设定
import sys
sys.setrecursionlimit(2000) #2000是新的递归层数
def reverse(s):
if s == "":
return s
else:
return reverse(s[1:]) + s[0]
str = input("请输入一个字符串: ")
print(reverse(str))
def factorial(num):
if num == 0:
return 1
else:
return num * factorial(num-1)
n = eval(input("请输入一个整数: "))
print(factorial(abs(int(n))))
import turtle
def koch(size, n):
if n == 0:
turtle.fd(size)
else:
for angle in [0, 60, -120, 60]:
turtle.left(angle)
koch(size/3, n-1)
def main():
turtle.setup(600,600)
turtle.speed(0)
turtle.penup()
turtle.goto(-200, 100)
turtle.pendown()
turtle.pensize(2)
level = 5
koch(400,level)
turtle.right(120)
koch(400,level)
turtle.right(120)
koch(400,level)
turtle.hideturtle()
main()
函数 | 描述 |
---|---|
abs() | 求数值的绝对值 |
divmod() | 返回两个数值的商和余数 |
max() | 返回可迭代对象哄的元素中的最大值或者所有参数的最大值 |
min() | 返回可迭代对象哄的元素中的最大值或者所有参数的最小值 |
pow() | 返回两个数值的幂运算或者其与指定整数的模值 |
round() | 对浮点数进行四舍五入值 |
sum() | 对元素类型是数值的可迭代对象中的每个元素求和 |
函数 | 描述 |
---|---|
bool() | 根据传入的参数的逻辑值创建一个新的布尔值 |
int() | 根据传入的参数创建一个新的整数 |
float() | 根据传入的参数创建一个新的浮点数 |
complex() | 根据传入的参数创建一个新的复数 |
str() | 返回一个对象的字符串表现形式 |
bytearray() | 根据传入的参数创建一个新的字节数组 |
bytes() | 根据传入的参数创建一个新的不可变字节数组 |
memoryview() | 根据传入的参数创建一个新的内存查看对象 |
ord() | 返回Unicode字符对应的整数 |
chr() | 返回整数所对应的Unicode字符 |
bin() | 将整数转化为2进制字符串 |
oct() | 将整数转化为8进制字符串 |
hex() | 将整数转化为16进制字符串 |
tuple() | 根据传入的参数创建一个新的元组 |
list() | 根据传入的参数创建一个新的列表 |
dictionary() | 根据传入的参数创建一个新的字典 |
set() | 根据传入的参数创建一个新的集合 |
frozenset() | 根据传入的参数创建一个不可变集合 |
enumerate() | 根据可迭代对象创建枚举对象 |
range() | 根据传入的参数创建一个新的range对象 |
iter() | 根据传入的参数创建一个新的可迭代对象 |
slice() | 根据传入的参数创建一个新的切片对象 |
super() | 根据传入的参数创建一个新的子类和父类关系的代理对象 |
object() | 创建一个新的object对象 |
函数 | 描述 |
---|---|
all() | 判断可迭代对象的每个元素是否都为True值 |
any() | 判断可迭代对象的元素是否为True值的元素 |
filter() | 使用指定方法过滤可迭代对象的元素 |
map() | 使用指定方法取作用传入的每个迭代对象的元素,生成新的可迭代对象 |
next() | 返回可迭代对象的下一个元素值 |
reversed() | 反转序列生成新的可迭代对象 |
sorted() | 对可迭代对象进行排序,返回一个新的列表 |
zip() | 聚合传入的每隔迭代器中的相同位置的元素,返回一个新的元祖类型迭代器 |
函数 | 描述 |
---|---|
help() | 返回对象的帮助信息 |
dir() | 返回对象或者当前作用域内的属性列表 |
id() | 返回对象的唯一标识符 |
hash() | 获取对象的哈希值 |
type() | 返回对象的类型,或者根据传入的参数创建一个新的类型 |
len() | 返回对象的长度 |
ascii() | 返回对象的可打印表字符串表现方式 |
函数 | 描述 |
---|---|
import() | 动态导入模块 |
isinstance() | 判断对象是否是类或者元祖中任意类元素的实例 |
issubclass() | 判断类是否是另一个类或者类型元组中任意类元素的子类 |
hasattr() | 检查对象是否含有属性 |
getsttr() | 获取对象的属性值 |
setattr() | 设置对象的属性值 |
delattr() | 删除对象的属性 |
callable() | 检查对象是否可被调用 |
format() | 格式化显示值 |
var() | 返回当前作用域内的局部变量和其值组成的字典,或者返回对象的属性列表 |
函数 | 描述 |
---|---|
globals() | 返回当前作用域内的全局变量和其值组成的字典 |
locals() | 返回当前作用域内的局部变量和其值组成的字典 |
函数 | 描述 |
---|---|
print() | 向标准输出对象打印输出 |
input() | 读取用户输入值 |
open() | 使用指定的模式和编码打开文件,返回文件读取对象 |
compile() | 将字符串编译为代码或者AST对象,使之能够通过exec语句来执行或者eval进行求值 |
eval() | 执行动态表达式求值 |
exec() | 执行动态语句块 |
repr() | 返回一个对象的支付穿表现形式 |
property() | 标示属性的装饰器 |
classmethod() | 标示方法为类方法的装饰器 |
staticmethod() | 标示方法为静态方法的装饰器 |
hasattr(list,'add')
Out[4]: False
hasattr(list,"append")
Out[5]: True
检查列表中的所有项目是否为 True:
mylist = [0, 1, 1]
x = all(mylist)
4.id()
返回元组对象的唯一 id,可以通过比较两个变量编号是否相同判断数据是否一致
反转列表的顺序,并打印每个项目:
alph = ["a", "b", "c", "d"]
ralph = reversed(alph)
for x in ralph:
print(x)
7.type() 返回数据对应类型
组合数据类型: 序列类型,集合类型,映射类型
序列类型:是一个元素向量,元素之间存在先后关系,通过序号访问,元素之间不排他。
集合类型:是一个元素集合,元素之间无序,相同元素在集合中唯一存在。
映射类型:是键—值数据项的组合,每个元素是一个键值对,表示为(key,value)
序列类型通用操作符和函数
操作符/函数 | 描述 |
---|---|
x in s | 如果x是s的元素,返回True,否则返回False |
x not in s | 如果x不是s的元素,返回True,否则返回False |
s+t | 连接s和t |
sn或ns | 将序列s复制n次 |
s[i] | 索引,返回序列的第i个元素 |
s[i:j] | 分片,返回包含序列s的第i到j个元素的子序列(不包含j,左闭右开) |
s[i:j:k] | 步骤分片,返回包含序列s的第i到第j个元素以k为步数的子序列 |
len(s) | 序列s的元素个数(长度) |
min(s) | 序列s中的最小元素 |
max(s) | 序列s中的最大元素 |
s.index(x[,i[,j]]) | 序列s中从i开始到j位置中第一次出现元素x的位置 |
s.count(x) | 序列s中出现x的总次数 |
>>> A = {"python", 123, ("python", 123)}
>>> print(A);
{123, 'python', ('python', 123)}
>>> B = set("pypy123"); #使用set建立集合
>>> print(B);
{'y', '3', 'p', '2', '1'}
>>> C = {"python", 123, "python", 123};
>>> print(C);
{123, 'python'}
集合类型的操作符
操作符 | 描述 |
---|---|
S - T 或s.difference(T) | 差,返回一个新集合,包括在集合S但不在T中的元素 |
S -= T 或s.difference_updata(T) | 差,更新集合S,包括在集合S但不在T中的元素 |
S & T 或 s.instersection(T) | 交,返回一个新集合,包括同时在集合S和T中的元素 |
S &= T 或s.instersection_updata(T) | 交,更新集合S,包括同时在集合S和T中的元素 |
S ^ T 或symmetric_difference(T) | 补,返回一个新集合,包括集合S和T中的非相同元素 |
S ^= T 或symmetric_difference(T) | 补,更新集合S,包括集合S和T中非相同的元素 |
S | T或s.union(T) | 并,返回一个新集合,包括在集合S和T中所有的元素 |
S |= T 或s.upadate(T) | 并,更新集合S,包括在集合S和T中所有的元素 |
S <= T 或 S < T或s…issubset(T) | 返回True或False,判断S和T的子集关系,前者s与T相同或是T的子集,返回True,后者可用于判断s是否为T的真子集 |
S >= T 或 S > T 或s.issuperset(T) | 返回True或False,判断S和T的包含关系,前者s与T相同或是T的超集,返回True,后者可用于判断s是否为T的真超集 |
集合类型的操作函数或方法
操作函数或方法 | 描述 |
---|---|
S.add(x) | 如果x不在集合S中,将x增加到S |
S.discard(x) | 移除S中元素x,如果x不在集合S中,不报错 |
S.remove(x) | 移除S中元素x,如果x不在集合S中,产生KeyError异常 |
S.clear() | 移除S中所有元素 |
S.pop() | 随机返回S的一个元素,更新S,若S为空产生KeyError异常 |
S.copy() | 返回集合S的一个副本 |
len(S) | 返回集合S的元素个数 |
x in S | 判断S中元素x,x在集合S中,返回True,否则返回False |
x not in S | 判断S中元素x,x不在集合S中,返回True,否则返回False |
set(x) | 将其他类型变量x转变为集合类型 |
映射类型是“键—值”的数据项的组合,每个元素是一个键值对,即元素是(key,value),元素之间是无序的,键值对(key,value)是一种二元关系。
键和值通过冒号连接,不同键值对通过逗号隔开。主要是以字典(dist)体现,字典是集合类型的延续,所以各个元素并没有顺序之分。键和值可以是任意数据类型,包括程序自定义的类型。
函数 | 描述 |
---|---|
cmp(tuple1, tuple2) | 比较两个元组元素。 |
tuple(seq) | 将列表转换为元组。 |
元组tuple是包含0个或多个数据项的不可变序列类型,并且元组生成后
固定的,其中的任何数据项不可替换或者删除
>>>print( 'abc', -4.24e93, 18+6.6j, 'xyz')
>>>x, y = 1, 2
>>>print( "Value of x , y : ", x,y)
abc -4.24e+93 (18+6.6j) xyz
Value of x , y : 1 2
>>>is=[1,"b",1]
>>>it=is #it只是对is的引用,it不包括真实数据,修改is同时也会修改it
>>>is[0]=0
>>>print(it)
[0,"b",1]
列表类型特有的函数和方法
函数/方法 | 描绘 |
---|---|
list(seq) | 将元组转换为列表 |
ls[i]=x | 替换列表ls第i项数据为x |
ls[i:j]=lt | 列表lt替换列表ls中第i到第j项数据(不包含第j项,下同) |
ls[i:j:k]=lt | 用列表lt替换列表ls中第i到第j项以k为步长的数据 |
del ls[i:j] | 删除列表ls第i到第j项数据。等价于ls[i:j]=[] |
del ls[i:j:k] | 删除列表ls第i到第j项以k为步长的数据 |
ls+=lt或ls.extend(lt) | 将列表lt元素增加到列表ls中 |
ls*=n | 更新列表ls,其元素重复n次 |
ls.append(x) | 在列表ls最后增加一个元素x |
ls.clear() | 删除ls中所有的元素 |
ls.copy() | 生成一个新列表,复制ls中的所有元素 |
ls.insert(i,x) | 在列表第i的位置新增插入元素x |
ls.pop(i) | 将列表ls中第i项元素取出并删除该元素 |
ls.remove(x) | 将列表ls中出现的第一个元素x删除 |
ls.reserve() | 列表ls中的元素反转 |
当使用一个列表改变另一个列表时,Python不要求两个列表长度一样,但遵循“多增少减”的原则
如下:
>>>vlist=list[range(5)]
>>>vlist[1:3] = ["new","bit",1]
>>>vlist
[0,"new","bit",1,3,4]
>>>vlist[1:3]=["fewer"]
>>>vilst
[0,"fewer",1,3,4]
#检查列表中是否存在 “apple”:
thislist = ["apple", "banana", "cherry"]
if "apple" in thislist:
print("Yes, 'apple' is in the fruits list")
d = { key1 : value1, key2 : value2 }
<值> =<字典变量>[<键>]
>>> d={}
>>>d['2^10']=1024
>>>print(d)
{'2^10:1024}
字典类型的函数和方法
函数和方法 | 描述 |
---|---|
返回所有键信息 | |
返回所有值信息 | |
返回所有的键值对 | |
键存在则返回相应值,否则返回默认值 | |
键存在则返回相应值,同时删除键值对,否则返回默认值 | |
随机从字典中取出一个键值对,以元组(key,value)形式返回 | |
删除所有键值对 | |
del |
删除字典中某一个键值对 |
如果键在字典中则返回Trule,否则False | |
< d>.fromkeys(list) | 定的多个键创建一个新字典,值默认都是 None,也可以传入一个参数作为默认的值。 |
list1 = ['Author', 'age', 'sex']
dic1 = dict.fromkeys(list1)
dic2 = dict.fromkeys(list1, 'Python')
# dic1 = {'Author': None, 'age': None, 'sex': None}
# dic2 = {'Author': 'Python', 'age': 'Python', 'sex': 'Python'}
如果希望方法返回的是列表类型,可以使用list()