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))
函数 说明
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'))
#注意:表达式是不能直接转换,字符串转换里面不能包含字母和特殊字符
作用:进行数值的运算
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.直接查询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='')
定义:
放在单引号 或者 双引号 里面的数字 字母 特殊字符 ----》字符串
格式:
name = '123'
name2 = "abc"
name3 = "@#"
注意:字符串里面的值不可改
#字符串的输出 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))
input()函数可以获取键盘输入的信息,返回的结果当做字符串处理，需要存储到一个变量里面
#字符串的输入 input()函数
name = input('请输入你的用户名:')
print(name)
print(type(name))
定义:
下标 ---- >编号
生活中的场景:
做火车--->找座位号
定义一个字符串变量
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)
定义:
截取变量里面的部分元素值---->切片
格式:[开始:结束:步长]
name = 'lishi'
#语法格式:[开始值:结束值:步长]
# print(name[::])
# print(name[3::]) #从下标3开始,返回后面所有元素
# print(name[:3:2])
#从后往前切 最后一个元素下标-1
# print(name[:-2:])
# print(name[::-2])
#1.字符串相加
str = 'hello'
str2 = ' world'
print(str+str2)
#2.输出多个world
# print(str2*3)
#3.字符串里面替换
#修改语法:str[下标] = 新的值
# print(str[1])
str[1] = 'y'
print(str)
#注意:字符串里面元素值不能修改
定义：
将一些普通的字符转换为具有特殊含义的字符-----》转义字符
#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')
如有一个字符串
myStr = "hello world"
定义：
检测str是否包含在myStr中，如果是返回开始元素的索引值，否则返回-1
格式：
myStr.find(str,start,end)
定义：
跟find方法一样，只不过如果str不在myStr中，或直接报错
格式：
myStr.index(str,start,end)
定义：
返回str在start和end直接在myStr中出现的次数
格式：
myStr.count(str,start,end)
replace:
定义：
把myStr中str1(旧元素)替换为str2(新元素)，如果指定了count，则替换不超过count次
格式：
myStr.replace(str1,str2,count)
split:
定义：
分割，以str为分隔符切片myStr,
返回的是列表（分割后的每一个元素作为列表中的元素（String）
格式：
myStr.split("",maxsplit)
capitalize:
定义：
把字符串中的第一个大写
格式：
myStr.capitalize()
title:
定义：
把字符串中的每一个单词的首字母大写
格式：
myStr.title()
swapcase
定义：
转换字符串中字母的大小写，小变大，大变小
startswith
定义：
检查字符串是否以object开头，如果是返回True，反之返回False
格式：
myStr.startswith(obj)
endswith
定义：
检查字符串是否以object结尾，如果是返回True，反之返回Flase
格式：
myStr.endswith(obj)
lower
定义：
转换myStr中所有大写字符为小写
格式：
myStr.lower()
upper
定义：
转换myStr中所有小写字符为大写
格式：
myStr.upper()
ljust:
定义：
返回一个原字符串左对齐，使用空格填充长度width,形成一个新的字符串
格式：
myStr.ljust(width)
width:表示字符串的长度
注意：
如果长度没有原始的字符串的长度长，默认使用字符串的长度
rjust:
定义：
返回一个原字符串右对齐，使用空格填充长度width, 形成一个新的字符串
格式：
myStr.rjust(width)
width: 表示字符串的长度
center:
定义：
返回一个原字符串居中，使用空格填充长度width, 形成一个新的字符串
格式：
myStr.center(width)
width: 表示字符串的长度
zfill:
定义:
返回一个长度为width的字符串,源字符串右对齐,前面补0
格式:
zfill(width)
lstrip:
定义:
删除myStr左边的空白字符
格式:
myStr.lstrip()
rstrip:
定义:
删除myStr右边的空白字符
格式:
myStr.rstrip()
strip:
定义:
删除myStr两端的空白字符
格式:
myStr.strip()
rfind
定义:
类似与find函数,从右边开始查找,如果找到返回元素的开始索引,反之返回-1
格式:
myStr,rfind(str,start,end)
rindex:
定义:
类似与index(),从右往左找,如果找到返回该元素的开始索引,反之直接报错
格式:
myStr.rindex(str,start,end)
partition:
把myStr以str分割成三部分 str前 str str后
返回的数据类型为元祖
格式:
myStr.partition(str)
rpartition()类似于partition()方法，只是该方法是从目标字符串的末尾也就是右边开始搜索分割符。
把myStr以str分割成三部分 str前 str str后
返回的数据类型为元祖
格式:
myStr.rpartition(str)
splitlines:
定义:
按照行进行分割,返回一个包含每行作为元素的列表
格式:
myStr.spiltlines()
myStr = "hello \nworld \npython \npython"
isalpha
定义:
如果myStr所有的字符都是字母,返回True,反之返回False
格式:
myStr.isalpha()
isdigit
定义:
如果myStr所有的字符都是数字,返回True,反之返回False
格式:
myStr.isdigit()
isalnum
定义:
如果myStr中所有的字符是字母或者数字,返回True,返回false
格式:
myStr.isalnum()
isspace
定义:
如果myStr中只包含空格,返回True,返回False
格式:
myStr.isspace()
join
定义:
myStr中每一个字符后面都会插入str,构造出一个新的字符串(不包含最后一个)
格式:
myStr.join(str)
eval:
定义:
函数用来执行一个字符串表达式，并返回表达式的值。
格式:
eval(str)
len:
定义:
返回字符串的长度(字符个数)
格式:
len(str)
chr:
定义:
函数使用一个范围range(256)内(0~255)整数作为参数,返回对应的字符
ACSII码
格式:
chr(0~255)
unichr:
定义:
unichr和chr一样,区别在于unichr返回的是unicode(将整数返回成unicode字符)
注意:
如果是配对usc2的unicode,它的允许范围是range(65536),0x0000-0xFFFF
如果是配对usc4的unicode,它的允许范围是range(1114112)
如果提供的参数不在允许的范围内,则会报valueError异常
注意:
如果想要使用unichr,需要导入unichr模块中的idna
from idna import unichr
列表：可以存储不同类型的多个数据 比如存放班级里面所有学生的名字
格式：
列表名 = [列表选项1,列表选项2,....,列表选项n]
例如：
nameList = ["xiaoming","xiaowang"，1,True,3.14,4+3j,None]
#特点:列表中存储的元素是可以不同类型的
列表也通样支持下标操作
下标特点：从0开始
nameList = ["xiaoming","xiaowang","xiaoliu"]
print(nameList[0])
print(nameList[1])
print(nameList[2])
思考：这种方式太麻烦,一般我们使用循环
for n in nameList:
print(n)
len = len(nameList)
i = 0
while i < len:
print(nameList[i])
i += 1
#列表元素的访问
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])
#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)
概述
修改元素的时候，要通过下标来确定需要进行的修改的元素，然后才能进行修改
a = [1,2,3,True,"hello"]
nameList[0] = 'daming'
print(nameList)
查找元素（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'))
删除元素（del/pop/remove）
del:根据下标进行删除
pop:删除最后一个元素
remove:根据元素的值进行删除
international = ['中国','韩国','日本','美国']
del international[2]
international.pop()
international.remove('中国')
print(international)
概述：
sort将列表按照特定的顺序重新的排列，默认由小到大
li = [9,100,78,0,111,-3]
print(li)
li.sort()
print('排序之后结果:')
print(li)
#reverse()逆序
li.reverse()
print('逆序之后的结果是:')
print(li)
#len() 求列表元素个数
nameList = ['张三','李四','王五','赵六']
print(len(nameList))
#max() 获取列表元素最大值
list = [100,99,2,9999]
print(max(list))
#min() 获取列表元素最小值
print(min(list))
概述：
类似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)
python的元祖和列表类似，不同之处在于元祖的元素不能修改，比如身份证号
格式：
元祖名 = (元祖元素1，元祖元素2.....元祖元素n)
本质：
一个有序的集合
#创建空的元祖
# 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))
概述： 生活中的字典 新华字典 根据偏旁或者拼音找到对应页面
例如：
学生信息列表，每一个学生有姓名，年龄，学号等
格式：
{key:value,key:value....}
定义一个变量info为字典类型
info = {"name":"周杰伦","age":30,"address":"北京"}
说明：
字典和列表一样，存储多种类型的数据
列表中找某一个元素，根据下标找,默认下标从0开始
字典中找元素，根据名字（就是:前面的那个值--》key）
字典：
字典中的每一个元素分为两个部分，前面是键 后面是值
例如：
name ---------> key
周杰伦 ---------> value
stu_info = {'name':'张三丰','age':30,'no':110}
print(stu_info) #获取所有的元素值
#获取单个元素值,获取姓名
#name就相当于生活中新华字典 根据偏旁或者拼音查找对应某个汉字
#语法格式:字典变量名[键的名字]
# print(stu_info['name'])
# print(stu_info['age'])
在我们不确定字典中是否存在某一个键而又想获取它的值，可以使用get(),可以设置默认值
res = stu_info.get('address','上海市')
print(res)
定义：
字典的每一个元素中的数据是可以进行修改，只需要通过key找到，即可修改
修改格式:
变量名[修改键名] = 新的值
#定义一个字典stu_info 存放学生学号 姓名 年龄
stu_info = {'no':110,'name':'张三','age':20}
#1.修改元素
#语法格式:字典变量名[对应键名] = 新的值
stu_info['age'] = 18
print(stu_info)
概述：
访问不存在的元素的key
#格式:
#变量名["键"] = 数据时,如果该键在字典中不存在,会自动创建
#添加手机号码
stu_info['mobile'] = 13248301214
print(stu_info)
del :删除指定的元素
clear()：清空字典
# del stu_info['age'] #删除字典中指定某个元素
# del stu_info #删除字典所有元素 相当于内存里面删除
# stu_info.clear() #删除字典所有元素,空字典
# print(stu_info)
#len():测量字典中,键值对的个数
print(len(stu_info))
#keys():返回一个包含字典中所有key的列表
print(stu_info.keys())
#values():返回一个包含字典中所有值value的列表
print(stu_info.values())
#items():返回一个包含所有(键 值)元祖的列表
print(stu_info.items())
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)
字典和列表比较：
1.查找和插入的速度较快，不会随着key-value的增加而变慢
2.需要占用较大的内存
列表占用空间小
集合与之前的列表和元祖类似，可以存储多种类型数据，这些数据不能重复
可以使用大括号 { } 或者 set()函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
格式:
parame = {value1,value2...}
或者
set = set(value,value2...)
开发场景:去除重复的数据
理解：
只有value,没有key
本质：
无序，不重复元素的集合
集合支持intersection(交集)，union(并集)，difference(差集)和sysmmetric difference(对称差集)等运算
集合的创建 ,需要列表/元祖/字典作为集合的元素
注意:重复的元素在集合中会被自动过滤掉
#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))
#添加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))
生成器的定义方式只需要将列表的[]换成()
如何理解？
列表是一个有序的集合,里面可以存储不同类型的多个数据,但是列表容器也是有限的,声明列表存储一百万条数据
使用场景:
可能实际使用的时候只会用到列表里面部分或者前几条数据,造成资源的浪费
优点:
生成器你使用列表里面数据的时候,才会在内存里面开辟空间,节省内存资源
# 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)
迭代：比如搭建房子一层层盖
访问集合元素的一种方式
迭代对象：
是一个可以记住遍历位置的对象
迭代器对象从集合的第一个元素开始访问，直到所有的元素访问完毕为止
对象:具体某个东西
一台电脑 一个水杯
序列:string,list,dict
迭代器的特点：
只能往前，不会后退
直接作用与for循环，for循环的数据类型有哪些？
一类：str list tuple dict set
二类：生成器
这些可以直接作用与for循环的对象的统称----》迭代对象 ： Iterable
可以使用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)
定义：
可以被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='')
生成器都是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)
8918
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
