Python数据类型和字符串操作
1.Number
1.1 Number数据类型(重点)
python3里面包含int/float/bool/complex(复数)
注意:
python2里面有一个long整形
python3里面只有一个整形,就是int,已经没有python2里面long整形
和其他语言一样,数值的赋值和计算都比较直观
获取变量的数据类型--->type(变量名)
通过type(),查询变量数据类型
python里面常见的赋值方式有3种
#1.交互性赋值方式
a,b,c,d = 10,3.5,True,3+4j
print(a,b,c,d)
print(type(a),type(b),type(c),type(d))
#2.连续性赋值方式
num = num2 = num3 = 10
print(num,num2,num3)
print(type(num),type(num2),type(num3))
print(id(num),id(num2),id(num3))
#3.单独赋值方式
a = 5
b = 3.8
c = False
d = 10+5j
print(a,b,c,d)
print(type(a),type(b),type(c),type(d))
print(id(a),id(b),id(c),id(d))
#id(变量名) 获取变量内存地址
#除了使用type(变量名)获取变量类型外,还可以通过isinstance(变量名,预测的数据类型)获取变量类型
# str2 = 'hello'
# li = [1,3,5,7]
# print(isinstance(str2,str))
# print(isinstance(li,str))
"""
它们之间的区别
type(变量名)获取变量的数据类型,它不会认为子类和父类是相同的数据类型
isinstance(变量名,预测的数据类型)预测变量是什么类型,它会认为子类和父类是相同的数据类型
"""
#案例:int/float/bool/complex
#1.整形
# a = -10
# print(a)
# print(type(a))
#2.浮点:带有小数点的数字 一般作为商品的价格
f = 3.8
print(f)
print(type(f))
#3.布尔:只有两个值True和False 转换整形1和0 一般应用在条件语句中
t = True
print(t)
print(type(t))
#4.复数:前面是数字,后面是字母
c = 3+4j
print(c)
print(type(c))
print(c.real) #实数
print(c.imag) #虚数
#空值:None 不能理解成0
b = None
print(b)
print(type(b))
1.2 常用的数据类型之间的转换
函数 说明
int(x) 将x转换为一个整数
float(x) 将x转换为一个浮点数
complex(real,[,imag]) 创建一个复数
str(x) 将对象x转换为字符串
repr(x) 将对象x转换为表达式字符串 用的不多
tuple(x) 将序列转换为元祖
list(x) 将序列x转换为列表
chr(x) 将一个整数转换为一个字符
unichr(x) 将一个整数转换为unicode字符
ord(x) 将一个字符转换为整数
hex(x) 将一个整数转换为一个十六进制的字符串
# str = '10'
# print(str)
# print(type(str))
#1.将字符串转换整形
#语法格式int(转换变量名)
# res = int(str)
# print(type(res))
#2.将字符串转换浮点型
# res2 = float(str)
# print(type(res2))
#3.将字符串转换列表
# res3 = list(str)
# print(type(res3))
#将整形转换字符串
# i = 20
# print(type(i))
# res4 = str(i)
# print(type(res4))
#特殊的字符不能转换
# s = 'abc'
# s = '12hello'
# s = '333'
s = '@#!'
res5 = int(s)
print(type(res5))
#只有正负号转换才有意义
print(type(int('+123')))
print(int('-12'))
print(int('12+3'))
print(int('12-5'))
#注意:表达式是不能直接转换,字符串转换里面不能包含字母和特殊字符
1.3 常用的模块
1.3.1 math
作用:进行数值的运算
import math
#使用语法:模块.函数名
#1.求绝对值
print(math.fabs(-5))
#2.向上取整 做分页使用
print(math.ceil(3.1))
#3.向下取整
print(math.floor(3.9))
#4.求平方根
print(math.pow(2,3))
#5.取整数部分和小数部分
print(math.modf(12.9999))
#6.求正弦
print(math.sin(3))
1.3.2 random
随机数
1.直接查询API
2.直接调用dir
随机数使用的场景
数学 打游戏 安全领域(验证码)
import random
#语法格式:模块名.函数
#dir()函数查看模块里面函数
# print(dir(random))
#1.求0~1之间的随机数
# print(random.random())
#2.返回随机范围的一个元素
# print(random.randrange(1,100,1))
"""
range(start,end,step) 创建一个数字列表
randrange(start,end,step)返回的是结果 随机的一个元素
"""
#3.返回随机的一个整数
# print(random.randint(0,10))
#4.返回随机的一个元素 做随机抽奖
# li = ['一块手表','一部苹果手机','10000元人民币','摩托车']
# print(random.choice(li))
#5.shuffle随机打乱序列里面元素
# li = ['一个水杯','一台电脑','一支笔','一副眼镜','一件风衣']
# random.shuffle(li)
# print(li)
#6.sample 随机获取部分元素
#生成6位数的随机验证码
str = '0123456789abcdefghijklmnopqrstuvwxyz'
res = random.sample(str,6)
for r in res:
print(r,end='')
2.字符串(String)
2.1 字符串的介绍
定义:
放在单引号 或者 双引号 里面的数字 字母 特殊字符 ----》字符串
2.2 python中字符串的格式
格式:
name = '123'
name2 = "abc"
name3 = "@#"
注意:字符串里面的值不可改
2.3 字符串的输出
#字符串的输出 print(变量名,end = '')函数 end取消换行
#1.输出
print(123)
print('明天是星期天',end=" ")
print('可以休息了')
str = 999
print(str)
#2.格式化输出
name = '张三丰'
age = 20
price = 100.5
print('我的姓名是:%s,我的年龄是:%d,我有%f人民币'%(name,age,price))
2.4 字符串的输入
input()函数可以获取键盘输入的信息,返回的结果当做字符串处理,需要存储到一个变量里面
#字符串的输入 input()函数
name = input('请输入你的用户名:')
print(name)
print(type(name))
2.5 下标和切片(重点)
2.5.1 下标
定义:
下标 ---- >编号
生活中的场景:
做火车--->找座位号
定义一个字符串变量
name = 'zhangsan'
name = 'zhangsan'
#语法格式:变量名[下标]获取元素值
#下标起始值是0,后面会自动增长
# print(name[0])
# print(name[1])
# print(name[2])
# print(name[3])
# print(name[4])
# print(name[5])
# print(name[6])
# print(name[7])
# print(name[8]) #注意:下标不能超出范围 或者报索引越界
#使用循环
# for temp in name:
# if temp == 'g':
# break
# print(temp)
2.5.2 切片(重点)
定义:
截取变量里面的部分元素值---->切片
格式:[开始:结束:步长]
name = 'lishi'
#语法格式:[开始值:结束值:步长]
# print(name[::])
# print(name[3::]) #从下标3开始,返回后面所有元素
# print(name[:3:2])
#从后往前切 最后一个元素下标-1
# print(name[:-2:])
# print(name[::-2])
2.6 字符串中常见的运算
#1.字符串相加
str = 'hello'
str2 = ' world'
print(str+str2)
#2.输出多个world
# print(str2*3)
#3.字符串里面替换
#修改语法:str[下标] = 新的值
# print(str[1])
str[1] = 'y'
print(str)
#注意:字符串里面元素值不能修改
2.7.字符串里面转义字符
定义:
将一些普通的字符转换为具有特殊含义的字符-----》转义字符
#1.\n换行
# print('hello \nworld')
#2.\\反斜杠符号
# print('hello\\123')
#3.\'单引号
# print('he\'ll\'o')
#4.\"双引号
# print("hell\"owor\"ld")
#5.\t 制表符,相当于一个空格
# print('hello\tworld')
#6.如果转义的字符非常多 可以使用r,表示默认不转义
print(r'a\nb\'c\t\\d')
2.8 字符串中的常见操作(重点)
如有一个字符串
myStr = "hello world"
2.8.1 find
定义:
检测str是否包含在myStr中,如果是返回开始元素的索引值,否则返回-1
格式:
myStr.find(str,start,end)
2.8.2 index
定义:
跟find方法一样,只不过如果str不在myStr中,或直接报错
格式:
myStr.index(str,start,end)
2.8.3 count
定义:
返回str在start和end直接在myStr中出现的次数
格式:
myStr.count(str,start,end)
2.8.4 replace
replace:
定义:
把myStr中str1(旧元素)替换为str2(新元素),如果指定了count,则替换不超过count次
格式:
myStr.replace(str1,str2,count)
2.8.5 split
split:
定义:
分割,以str为分隔符切片myStr,
返回的是列表(分割后的每一个元素作为列表中的元素(String)
格式:
myStr.split("",maxsplit)
2.8.6 capitalize
capitalize:
定义:
把字符串中的第一个大写
格式:
myStr.capitalize()
2.8.7 title
title:
定义:
把字符串中的每一个单词的首字母大写
格式:
myStr.title()
2.8.8 swapcase
swapcase
定义:
转换字符串中字母的大小写,小变大,大变小
2.8.9 startswith
startswith
定义:
检查字符串是否以object开头,如果是返回True,反之返回False
格式:
myStr.startswith(obj)
2.8.10 endswith
endswith
定义:
检查字符串是否以object结尾,如果是返回True,反之返回Flase
格式:
myStr.endswith(obj)
2.8.11 lower
lower
定义:
转换myStr中所有大写字符为小写
格式:
myStr.lower()
2.8.12 upper
upper
定义:
转换myStr中所有小写字符为大写
格式:
myStr.upper()
2.8.13 ljust
ljust:
定义:
返回一个原字符串左对齐,使用空格填充长度width,形成一个新的字符串
格式:
myStr.ljust(width)
width:表示字符串的长度
注意:
如果长度没有原始的字符串的长度长,默认使用字符串的长度
2.8.14 rjust
rjust:
定义:
返回一个原字符串右对齐,使用空格填充长度width, 形成一个新的字符串
格式:
myStr.rjust(width)
width: 表示字符串的长度
2.8.15 center
center:
定义:
返回一个原字符串居中,使用空格填充长度width, 形成一个新的字符串
格式:
myStr.center(width)
width: 表示字符串的长度
2.8.16 zfill
zfill:
定义:
返回一个长度为width的字符串,源字符串右对齐,前面补0
格式:
zfill(width)
2.8.17 lstrip
lstrip:
定义:
删除myStr左边的空白字符
格式:
myStr.lstrip()
2.8.18 rstrip
rstrip:
定义:
删除myStr右边的空白字符
格式:
myStr.rstrip()
2.8.19 strip
strip:
定义:
删除myStr两端的空白字符
格式:
myStr.strip()
2.8.20 rfind
rfind
定义:
类似与find函数,从右边开始查找,如果找到返回元素的开始索引,反之返回-1
格式:
myStr,rfind(str,start,end)
2.8.21 rindex
rindex:
定义:
类似与index(),从右往左找,如果找到返回该元素的开始索引,反之直接报错
格式:
myStr.rindex(str,start,end)
2.8 22 partition
partition:
把myStr以str分割成三部分 str前 str str后
返回的数据类型为元祖
格式:
myStr.partition(str)
2.8.23 rpartition
rpartition()类似于partition()方法,只是该方法是从目标字符串的末尾也就是右边开始搜索分割符。
把myStr以str分割成三部分 str前 str str后
返回的数据类型为元祖
格式:
myStr.rpartition(str)
2.8.24 splitlines
splitlines:
定义:
按照行进行分割,返回一个包含每行作为元素的列表
格式:
myStr.spiltlines()
myStr = "hello \nworld \npython \npython"
2.8.25 isalpha
isalpha
定义:
如果myStr所有的字符都是字母,返回True,反之返回False
格式:
myStr.isalpha()
2.8.26 isdigit
isdigit
定义:
如果myStr所有的字符都是数字,返回True,反之返回False
格式:
myStr.isdigit()
2.8.27 isalnum
isalnum
定义:
如果myStr中所有的字符是字母或者数字,返回True,返回false
格式:
myStr.isalnum()
2.8.28 isspace
isspace
定义:
如果myStr中只包含空格,返回True,返回False
格式:
myStr.isspace()
2.8.29 join
join
定义:
myStr中每一个字符后面都会插入str,构造出一个新的字符串(不包含最后一个)
格式:
myStr.join(str)
2.8.30 eval
eval:
定义:
函数用来执行一个字符串表达式,并返回表达式的值。
格式:
eval(str)
2.8.31 len
len:
定义:
返回字符串的长度(字符个数)
格式:
len(str)
2.8.32 chr
chr:
定义:
函数使用一个范围range(256)内(0~255)整数作为参数,返回对应的字符
ACSII码
格式:
chr(0~255)
2.8.33 unichr
unichr:
定义:
unichr和chr一样,区别在于unichr返回的是unicode(将整数返回成unicode字符)
注意:
如果是配对usc2的unicode,它的允许范围是range(65536),0x0000-0xFFFF
如果是配对usc4的unicode,它的允许范围是range(1114112)
如果提供的参数不在允许的范围内,则会报valueError异常
注意:
如果想要使用unichr,需要导入unichr模块中的idna
from idna import unichr
3.列表(重点)
3.1 列表介绍
列表:可以存储不同类型的多个数据 比如存放班级里面所有学生的名字
3.2 列表的格式
格式:
列表名 = [列表选项1,列表选项2,....,列表选项n]
例如:
nameList = ["xiaoming","xiaowang",1,True,3.14,4+3j,None]
#特点:列表中存储的元素是可以不同类型的
3.3 列表的下标
列表也通样支持下标操作
下标特点:从0开始
nameList = ["xiaoming","xiaowang","xiaoliu"]
print(nameList[0])
print(nameList[1])
print(nameList[2])
思考:这种方式太麻烦,一般我们使用循环
3.4 列表的循环遍历
3.4.1 使用for循环
for n in nameList:
print(n)
3.4.2 while循环
len = len(nameList)
i = 0
while i < len:
print(nameList[i])
i += 1
3.5 列表中常见的操作(非函数)
#列表元素的访问
list = [1,2,3,4,5,10]
#注意不要越界(下标超出了可表示的范围)
#元素的替换
#修改语法格式:列表变量名[下标] = 新的值
# list[2] = 100
# print(list)
#列表的组合
# list2 = [7,8,9]
# print(list+list2)
#列表的重复
# print(list*3)
#in判断元素是否在列表中,如果找到返回True,反之False
# if 10 in list:
# print('True')
# else:
# print('False')
#截取(包左不包右)
print(list[0:3])
3.6 列表中常见的操作(函数)
3.6.1 添加元素(append,extend,insert)
#1.通过append函数可以向列表中添加元素
#定义一个变量nameList的类型为列表,默认有三个元素
nameList = ["xiaoming","xiaowang","xiaoli"]
# print(nameList)
# print('添加之前:')
# nameList.append('xiaoqiang')
# print(nameList)
#2.extend:通过该函数可以向列表中添加元素
# a = [1,2]
# b = [3,4]
# a.extend(b)
# print(a)
#3.insert(index,object):在指定的位置index前插入元素object
# nameList.insert(1,'xiaoyao')
# print(nameList)
3.6.2 修改元素
概述
修改元素的时候,要通过下标来确定需要进行的修改的元素,然后才能进行修改
a = [1,2,3,True,"hello"]
nameList[0] = 'daming'
print(nameList)
3.6.3 查找元素(in/not in/index/count)
查找元素(in,not in,index,count)
定义:
查找:看看指定的元素是否存在
python中查找的常见的方法
in(存在):如果存在返回的结果为True,反之False
not in(不存在):如果不存在结果为True,反之False
#根据键盘录入信息查找 某个人是否存在
# name = input('请输入你要查找的姓名:')
# if name not in nameList:
# print('存在')
# else:
# print('不存在')
# print(nameList.index('xiaoli'))
# print(nameList.count('xiaoli'))
3.6.4 删除元素(del/pop/remove)
删除元素(del/pop/remove)
del:根据下标进行删除
pop:删除最后一个元素
remove:根据元素的值进行删除
international = ['中国','韩国','日本','美国']
del international[2]
international.pop()
international.remove('中国')
print(international)
3.6.5 排序sort
概述:
sort将列表按照特定的顺序重新的排列,默认由小到大
li = [9,100,78,0,111,-3]
print(li)
li.sort()
print('排序之后结果:')
print(li)
#reverse()逆序
li.reverse()
print('逆序之后的结果是:')
print(li)
3.7 列表中常见的函数
#len() 求列表元素个数
nameList = ['张三','李四','王五','赵六']
print(len(nameList))
#max() 获取列表元素最大值
list = [100,99,2,9999]
print(max(list))
#min() 获取列表元素最小值
print(min(list))
3.8 列表的嵌套
概述:
类似while循环的嵌套,列表也支持嵌套
一个列表中元素为一个列表
格式:
列表名 = [[],[],[]]
例如:
schoolNames = [["清华大学","北京大学"],["工程大",'立信'],['合肥汽修院校']]
练习:
一个学校,有3个办公室,现在有8个老师等待分配工位,请编写程序,完成随机分配
要求:
办公室的编号,人数 具体是谁
#定义一个嵌套列表存储学校里面3个办公室
offices = [[],[],[]]
#定义一个列表存储8位老师的名字
nameList = ['张学友','刘德华','黎明','郭富城','王菲','张柏芝','张韶涵','杨颖']
import random
#循环获取每个老师的名字
for name in nameList:
#使用随机数产生3个办公室
index = random.randint(0,2)
#offices[0] offices[1] offiices[2]
offices[index].append(name)
print(offices)
i = 1 #办公室编号
for tempNames in offices:
print('办公室%d的人数是%d'%(i,len(tempNames)))
i += 1
for name in tempNames:
print('老师的名字是%s'%name)
4.元祖(熟练)
4.1 元祖的介绍和格式
python的元祖和列表类似,不同之处在于元祖的元素不能修改,比如身份证号
格式:
元祖名 = (元祖元素1,元祖元素2.....元祖元素n)
本质:
一个有序的集合
4.2 元祖的常见的操作
#创建空的元祖
# tuple = ()
# print(tuple)
# print(type(tuple))
#定义元祖的时候只定义一个元素
# tuple2 = (1,)
# print(type(tuple2))
#元祖的删除
tuple3 = (1,3,5,7)
# print(tuple3)
# del tuple3
# print('删除之后的元祖:')
# print(tuple3)
#元祖的组合
# tuple4 = (0,7,8)
# print(tuple3+tuple4)
#判断元素是否在元祖中-->in not in
# if 10 not in tuple3:
# print('True')
# else:
# print('False')
#元祖的截取
# print(tuple3[0:3])
#元祖的嵌套(二维元祖),元素是一维元祖
tuple5 = ((1,3,5),(2,4,6))
# print(tuple5[0][2])
# for temp in tuple5:
# for t in temp:
# print(t,end='')
#len():返回元祖中元素的个数
print(len(tuple5))
#max/min:最大值和最小值
tuple6 = (99,0,101,23,23,23)
print(max(tuple6))
print(min(tuple6))
#count/index
print(tuple6.count(23))
print(tuple6.index(101))
5.字典(重点)
5.1 字典的概述
概述: 生活中的字典 新华字典 根据偏旁或者拼音找到对应页面
例如:
学生信息列表,每一个学生有姓名,年龄,学号等
5.2 字典的格式
格式:
{key:value,key:value....}
定义一个变量info为字典类型
info = {"name":"周杰伦","age":30,"address":"北京"}
说明:
字典和列表一样,存储多种类型的数据
列表中找某一个元素,根据下标找,默认下标从0开始
字典中找元素,根据名字(就是:前面的那个值--》key)
字典:
字典中的每一个元素分为两个部分,前面是键 后面是值
例如:
name ---------> key
周杰伦 ---------> value
5.3 根据键找值
stu_info = {'name':'张三丰','age':30,'no':110}
print(stu_info) #获取所有的元素值
#获取单个元素值,获取姓名
#name就相当于生活中新华字典 根据偏旁或者拼音查找对应某个汉字
#语法格式:字典变量名[键的名字]
# print(stu_info['name'])
# print(stu_info['age'])
5.4 get函数
在我们不确定字典中是否存在某一个键而又想获取它的值,可以使用get(),可以设置默认值
res = stu_info.get('address','上海市')
print(res)
5.5 字典中常见的操作
5.5.1 修改元素
定义:
字典的每一个元素中的数据是可以进行修改,只需要通过key找到,即可修改
修改格式:
变量名[修改键名] = 新的值
#定义一个字典stu_info 存放学生学号 姓名 年龄
stu_info = {'no':110,'name':'张三','age':20}
#1.修改元素
#语法格式:字典变量名[对应键名] = 新的值
stu_info['age'] = 18
print(stu_info)
5.5.2 添加元素
概述:
访问不存在的元素的key
#格式:
#变量名["键"] = 数据时,如果该键在字典中不存在,会自动创建
#添加手机号码
stu_info['mobile'] = 13248301214
print(stu_info)
5.5.3 删除元素
del :删除指定的元素
clear():清空字典
# del stu_info['age'] #删除字典中指定某个元素
# del stu_info #删除字典所有元素 相当于内存里面删除
# stu_info.clear() #删除字典所有元素,空字典
# print(stu_info)
5.5.4 字典常见的函数的使用
#len():测量字典中,键值对的个数
print(len(stu_info))
#keys():返回一个包含字典中所有key的列表
print(stu_info.keys())
#values():返回一个包含字典中所有值value的列表
print(stu_info.values())
#items():返回一个包含所有(键 值)元祖的列表
print(stu_info.items())
5.5.5 字典的遍历
dict = {'name':'张三','age':20,'address':'上海市','no':110}
#1.获取字典中所有键名 keys()
# allkeys = dict.keys()
# for temp in allkeys:
# print(temp,end=' ')
#2.获取字典中所有的值 values()
# allValues = dict.values()
# print(allValues)
# for temp in allValues:
# print(temp,end=' ')
#3.获取字典中键值对
items = dict.items()
# print(items)
for key,value in items:
print(key,value)
5.6 字典和列表优缺点
字典和列表比较:
1.查找和插入的速度较快,不会随着key-value的增加而变慢
2.需要占用较大的内存
列表占用空间小
6.集合(熟练)
6.1 集合的概述
集合与之前的列表和元祖类似,可以存储多种类型数据,这些数据不能重复
可以使用大括号 { } 或者 set()函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。
格式:
parame = {value1,value2...}
或者
set = set(value,value2...)
开发场景:去除重复的数据
理解:
只有value,没有key
本质:
无序,不重复元素的集合
集合支持intersection(交集),union(并集),difference(差集)和sysmmetric difference(对称差集)等运算
6.2 集合的创建
集合的创建 ,需要列表/元祖/字典作为集合的元素
注意:重复的元素在集合中会被自动过滤掉
#1.set函数创建
# res = set([1,2])
# res = set({1:'hello',2:'world'})
# res = set((3,4))
# print(res)
# print(type(res))
#2.大括号创建{}
# fruit = {'apple','orange','banana'}
# print(fruit)
# print(type(fruit))
3.3 集合中常见的操作(添加/删除/遍历/交集/并集/差集)
#添加add
# set = set([1,2,3,4]) #集合的元素不能是数字
# set.add(5)
# set.add(5) #不能添加重复的元素
# set.add([5,6]) #列表元素值可以修改
# set.add({5:'hello',6:'world'}) #字典元素值可以修改
# set.add((5,6))
# print(set)
# print(type(set))
#update()可以插入list/tuple/String打碎插入(无序,去重)
# set.update([5,6])
# set.update((7,8))
# set.update({9:'hello',10:'world'})
# set.update('0')
# print(set)
#删除
# set.clear()
# print(set)
#遍历for
# for temp in set:
# print(temp,end='')
#交集/差集/并集 开发场景:好友之间的共同爱好
#交集 &
s = set([1,2,3,4])
s2 = set([3,4,5,6])
print(s & s2)
print(s.intersection(s2))
#并集 |
print(s | s2)
print(s.union(s2))
#差集 -
print(s - s2)
print(s.difference(s2))
#差集 对称差集
print(s.symmetric_difference(s2))
7. 生成器(重点)
7.1 生成器的定义
生成器的定义方式只需要将列表的[]换成()
如何理解?
列表是一个有序的集合,里面可以存储不同类型的多个数据,但是列表容器也是有限的,声明列表存储一百万条数据
使用场景:
可能实际使用的时候只会用到列表里面部分或者前几条数据,造成资源的浪费
优点:
生成器你使用列表里面数据的时候,才会在内存里面开辟空间,节省内存资源
7.2 生成器的创建
# li = [1,3,5,7,9] #数据被写死了,动态创建列表
# print(li)
#通过列表生成式创建列表
# li = [x*2 for x in range(5)]
# print(li)
#生成器的创建方式只需要将[]改成()
#创建一个生成器
generator = (x*2 for x in range(5))
# print(generator)
#使用next()获取生成器里面每个元素值
# print(next(generator))
# print(next(generator))
# print(next(generator))
# print(next(generator))
# print(next(generator))
# print(next(generator)) #超出范围,报错
"""
生成器每次返回的是一个算法,每使用一次next可以获取一个元素值,直到获取最后一个,
如果超出了范围程序报错,使用for循环迭代它,不用担心超出范围报错的问题
"""
# for temp in generator:
# print(temp,end='')
#求斐波那契数列求5个值
#1 1 2 3 5 8 13 21 除第一个和第二个数之外,后面每个元素都是由前两个数相加
#1.用函数实现
# a = 0 #控制循环的次数
# b = 0
# c = 1
# while a < 5:
# temp = c #定义临时变量保存c的值
# c = b + c #最左边的c相当于求后面的数值
# b = temp
# print(b)
# a += 1
"""
1->temp = c,c = 1 b = 1
2->temp = 1 ,c = 2 b = 1
3->temp = 2,c= 3, b = 2
"""
"""
a = 10 b = 5 temp
temp = a
a = b
b = temp
"""
# def flib():
# a = 0
# b,c = 0,1 #交互性赋值方式
# while a < 5:
# temp = c
# c = b + c
# # b = temp
# b = temp
# print(b)
# a += 1
# #调用函数
# flib()
#2.使用生成器实现 yield
# def flib2():
# a = 0
# b,c = 0,1
# while a < 5:
# print(c)
# b,c = c,b+c
# a += 1
# #调用函数
# flib2()
"""
b,c = c,b+c
temp = c
c = b + c
b = temp
或者
b,c = 1,1
"""
def flib3():
a,b,c=0,0,1 #交互性赋值方式
while a < 5:
yield c
b,c = c,b+c
a += 1
#调用函数
res = flib3()
# print(res)
# print(next(res))
# print(next(res))
# print(next(res))
# print(next(res))
# print(next(res))
#使用循环
# for t in res:
# print(t,end='')
"""
yield关键字类似return关键字,每次迭代使用yield返回后面一个元素值,
下一次迭代遇到yield会在上一次yield结束的位置后面继续执行
return返回函数体的结果,它能够记住访问元素的位置
"""
for temp in [1,2,3,4,5]:
# print(temp,end='')
pass
#pass空语句,保持程序结构的完整性 相当于起到占位的作用
def odd():
print('第一次')
yield 1
print('第二次')
yield 2
print('第三次')
yield 3
result = odd()
# print(result)
try:
print(next(result))
print(next(result))
print(next(result))
print(next(result)) #超出了范围 报错
except StopIteration as message:
print('错误的原因是:',message)
# while True:
# try: #如果try里面放的代码没有错误正常执行,把可能出现错误的代码放到try里面进行捕获
# print(next(result))
# except StopIteration as s: #StopIteration捕获到错误类型 as 起别名关键字 s起的别名
# print('原因是:',s)
# break
def num(s):
n = int(s)
return 10 / n
try:
print(num(0))
except ZeroDivisionError as e:
print('原因是:',e)
8.迭代器(重点)
8.1 迭代器的概述
迭代:比如搭建房子一层层盖
访问集合元素的一种方式
迭代对象:
是一个可以记住遍历位置的对象
迭代器对象从集合的第一个元素开始访问,直到所有的元素访问完毕为止
对象:具体某个东西
一台电脑 一个水杯
序列:string,list,dict
迭代器的特点:
只能往前,不会后退
8.2 迭代对象
直接作用与for循环,for循环的数据类型有哪些?
一类:str list tuple dict set
二类:生成器
这些可以直接作用与for循环的对象的统称----》迭代对象 : Iterable
8.3 判断是否可以迭代
可以使用isinstance()来判断一个对象是否是Iterable
需要使用一个模块collections
from collections import Iterable,Iterator #导入模块里面部分函数
#哪些数据类型是迭代对象
a = isinstance([],Iterable)
b = isinstance((),Iterable)
c = isinstance({},Iterable)
d = isinstance(set(),Iterable)
# e = isinstance(10000,Iterable) #数字类型,值不能修改
f = isinstance('haha',Iterable)
g = isinstance((x*2 for x in range(5)),Iterable) #有向下执行的原理 next()每次获取下一个元素值
print(a)
print(b)
print(c)
print(d)
# print(e)
print(f)
print(g)
8.4 迭代器的使用
定义:
可以被next()函数调用并且不断的返回下一个值的对象----》迭代器 Iterator
list = (1,3,5,7,9,True,'ha')
#使用iter函数创建一个迭代器对象
res = iter(list)
# print(res)
#使用next()函数获取下一个元素值
print(next(res))
print(next(res))
print(next(res))
print(next(res))
print(next(res))
print(next(res))
print(next(res))
# print(next(res)) #超出范围 报错
#优化版 使用循环
for temp in res:
print(temp,end='')
8.5 iter()函数
生成器都是Iterator对象,但是list dict str 都是迭代对象但是不是迭代器,可以通过iter函数转换
from collections import Iterator
a = isinstance(iter([]),Iterator)
b = isinstance(iter(()),Iterator)
c = isinstance(iter({}),Iterator)
d = isinstance(iter(set()),Iterator)
# e = isinstance(iter(10000),Iterator) #数字类型,值不能修改
f = isinstance(iter('haha'),Iterator)
g = isinstance((x*2 for x in range(5)),Iterator) #有向下执行的原理 next()每次获取下一个元素值
print(a)
print(b)
print(c)
print(d)
# print(e)
print(f)
print(g)