1.2 数据类型
1.2.1 基本数据类型
python中的基本数据类型有:
- 字符串:str;(简单数据类型)
- 数字:整型int、浮点型float、复数型complex;(简单数据类型)
- 布尔型:bool;(简单数据类型)
- 集合:set;(复合数据类型)
- 序列:列表list、元组tuple;(复合数据类型)
- 字典:dict;(复合数据类型)
1.2.2 数据类型相关操作
(1)字符串
四种格式的字符串内存地址:
# 三引号内容涉及换行保留格式的话,即便内容相同,其内存中的地址与其他两个也是不一样的。但写在一行时是有相同地址的。如下:
s1='abc'
s2="abc"
s3='''abc'''
s4="""abc"""
print(id(s1),id(s2),id(s3),id(s4)) # 三个内容相同的字符串在内存中的地址是一样的
# 用input函数赋值时,相同内容的字符串赋给两个变量,两个变量的地址不同
字符串可以进行一些运算:
# 加法运算
s3 = s1+s2
# 乘法运算
s4 = s1*5
# 关系运算in
name = 'steven'
result = 't' in name #返回结果是布尔类型,结果为True
result1 = 'tv' in name #False,因为name中的tv不相连
result2 = 'te' in name #True
python中的字符串是一种可迭代类型,可以进行与列表一样的元素定位与切片:
- 字符串切片操作:str[m:n],包前不包后;
- 字符串切片操作:str[m:n],m省略表示从头切,n省略表示切到尾,都不写即取全字符串;
- 字符串切片操作:str[m:n:l],l表示按步长l切片,l为负表示倒序取值;str[m:n:l],步长方向与mn大小方向必须一致;
- 以上操作中的m、n、l可以用正向递增序号的取法,也可以用反向递减序号的取法。
pthon中有一个内建函数len()可以返回字符串的长度,返回值为整型。如下:
#随机取值四位验证码
s1 = 'abcdefghijklmnopqrstuvwxyz'
s2 = s1.upper()
s3 = '1234567890'
s = s1+s2+s3
import random
code = ''
for i in range(4):
ran = random.randint(0,len(s)-1)
code += s[ran]
print('验证码:',code) #这样的输出逗号前后两部分之间会加一个空格
print('验证码:'+code) #这样的输出加号前后两部分是直接连接的,不带空格
#输入验证码
user_input=input('请输入验证码:')
if user_input.lower() == code.lower():
print('验证成功!')
else:
print('验证失败,请重新输入验证码!')
字符串有与大小写相关的内置方法:
- str.capitalize() 将字符串的第一个字符转为大写;
- str.title() 将字符串中的每个单词大写,即时行标题化;
- str.istitle() 判断字符串是否标题化,返回结果为True或Flase;
- str.upper() 将字符串所有字母大写;
- str.lower() 将字符串所有字母小写;
- 以上方法只要带上is,像line7那样,都表示判断。
字符串有查找与替换相关的方法:
- .find(str,beg=0,end=len(string)) ,检测字符串是否包含在字符串中,如果指定范围beg和end,则检测是否包含在指定范围内,如果含有则返回索引位置,没有则返回-1。如果可以找到,则返回目标在字符串中第一次出现的位置。示例:str.find(‘j’,1,6);.rfind() ,从所给字符串的右侧开始寻找;.lfind() ,从所给字符串的左侧开始寻找;
- .index(str,beg=0,end=len(string)) ,与find方法一样,只不过如果检索字符不在字符串中会报异常;.lindex();.rindex();
- .replace(old,new[,max]) ,将老字符串替old换为新字符串new,如果规定max则替换不超过max次。
字符串有编码与解码相关的方法:
- .encode(encoding=‘UTF-8’,errors=‘strict’) ,以encoding指定的编友方式编码,默认为UTF-8,如果出错则报一个ValueError的异常,除非errors指定的是’ignore’或’replace’。encoding可以是gbk、gb2312、unicode、utf-8;
- .decode(encoding=‘UTF-8’) ,解码 。
字符串有匹配相关的方法:
- .startswith(‘str’) #判断字符串是否以指定的str开头;
- .endswith(‘str’) #判断字符串是否以指定的str结尾。
字符串中以is开头的方法,进行某种判断:
- .isalnum() #判断字符串是否由字母或数字组成。如果字符串至少有一个字符且所有的字符都是字母或数字则返回True,否则返回Flase;
- .isalpha() #判断字符串是否由字母组成。如果字符串至少有一个字符且所有字符都是字母组成则返回True;
- .isdegit() #判断字符串是否由数字组成。都是由数字组成则返回True;
- .islower() #判断是否都是小写。只要是有可区分大小写的字符,且其中都是小写,返回True;
- .isupper() #判断是否都是大写。
字符串有分割操作相关的方法:
-
.join() #以指定的字符串作为分隔,将seq中所有的元素合并为一个新的字符串;
-
.split(str,num=string.count(str)) #按指定字符分割字符串,分割后的字符串以列表保存,如果指定了num值则仅截取num+1个字符串,即返回num+1个列表元素;
-
.count(‘str’) #寻找字符串中指定字符的个数。
字符串有消除空格相关的方法:
-
.lstrip() #截掉字符串左边的空格或指定字符;
-
.rstrip() #截掉字符串右边的空格或指定字符;
-
.strip() #同时执行lstrip和rstrip。
字符串的eval()函数,去掉字符串最外侧的引号。例如:eval(“1”),将字符串“1”变为了数字1。
(2)列表
定义列表的内存分配:
names = ['jack',2,'lucy','superman', 1] #此即定义了一个列表。列表中的元素可以是任何类型
#定义空列表仍然会被分配地址
nos = []
print(id(names),id(nos))
print(names[1]) # 可以通过索引取出列表中的元素,索引方式与字符串相同
len(names) # len函数也可以获取列表的长度
列表中元素的增删查改:
#列表可以参与循环
for name in names:
print(name)
#列表可以参与判断
if 'superman' in names:
pass
#修改列表中的数值
names[-1] = '我' #先找到列表中的目标元素,然后赋值我们要改的值
#删除列表中的元素
del names[2]
#循环删除列表中的相应元素时,由于列表的长度在不断变化,因此可以用while循环代替for循环进行。
names = ['jack','tom','lucy','superman','ironman']
l = len(names)
i = 0
while i<l:
if 'tom' in names[i] or 'jack' in names[i]:
del names[i]
l-=1
i+=1
print(names)
#但用以上删除方式,由于列表的长度变化导致元素索引变化,进而容易出现漏删的问题
words = ['hello','goods','gooo','world','digot','alphago']
w = input('请输入一个单词:')
i = 0
l = len(words)
while i<l:
if w in words[i]:
del words[i]
l-=1
i-=1 #此处将用continue也可,用continue可以跳过i+=1但续继持行循环
#使用i-=1在删除的同时,使i减1,在后续运算中会加1,以此保持i的值不变
#continue的作用是:不执行continue下方的代码,但继续执行循环
i+=1
print(words)
#for...in...与if...in...
i=0
for w in ['goods','good','abc','aaaa']:
print('good' in w) #打印判断的结果,输出为两次True,两次False
print('------>',i)
i += 1
#if后用带in的表达式,但if与in不是固定组合。for...in...是一个固定组合作为循环条件的一个判断。
'''
列表添加元素
# list.append(el) #追加,末尾追加,新增元素出现在列表最末
# list.extend(el) #有拆分特性,会把输入的字符串拆分成单个字符
#用于列表的合并,可以把A列表拆成元素加入B列表
#el不能是整型项
#+运算符号也可以实现两个列表的合并
# list.insert(index=2,el) #插入,指定位置插入,index指定位置,el是要放入的元素
'''
#循环向列表中输入元素
girls = []
name = input('请输入你心目中的美女的名字:')
while True:
name = input('请输入你心目中的美女的名字:')
if name=='quit':
break
girls.append(name)
print(girls)
#extend的使用
girls1 = []
girls2 = []
girls3 = []
list1 = ['杨超越','热巴','佟丽娅','杨幂','赵丽颖','刘亦菲','黑嘉嘉',100,99.9]
girls1.extend('123')
girls2.extend('黑嘉嘉')
girls3.extend(list1)
print(girls1,girls2,girls3)
#产生随机数列表
import random
random_list = []
for i in range(10):
ran = random.randint(1,50)
random_list.append(ran)
print(random_list)
#产生元素不重复的随机数列表
#for i in range(10): 如果采用的是for循环,输出的个数不一定是10个
import random
random_list = []
i=0
while i<10:
ran = random.randint(1,20)
if ran not in random_list:
random_list.append(ran)
i+=1
print(random_list)
#找出列表中的最大值
max_value = max(random_list) #使用内置函数找最大值;也可以用循环求最大值
print(max_value)
#列表的切片操作
list1 = ['杨超越','热巴','佟丽娅','杨幂','赵丽颖','刘亦菲','黑嘉嘉',100,99.9]
print(list1[3:6]) #列表的切片与字符串的切片操作类似,切出的结果依然是列表
#列表的切片同样支持正向递增与反向递减序号;同样地也支持步长切片
#列表的其他内置函数:删除相关的
'''
del list[index]
list.remove() #移除列表中的第一个匹配项
pop() #弹栈,不传值时默认移除列表中的最后一个元素;还可以指定索引删除;
clear() #清除列表(删除列表中的所有元素)
'''
hotpot_list = ['海底捞','呷哺呷哺','张亮麻辣烫','热辣一号','宽板凳','杨国福麻辣烫','张亮麻辣烫']
result = hotpot_list.remove('张亮麻辣烫') #如果找不到对应元素则报异常
print(result) #上一语句的remove函数不返回值,因此无输出
print(hotpot_list)
result = hotpot_list.pop() #可以返回要删除的那个元素
print(result)
print(hotpot_list)
result=hotpot_list.clear()
print(result)
#.reverse(),逆序输出列表,改变原列表的元素位置;区别于切片的倒序取出,倒序取出只是生成倒序序列而不改变原列表的元素顺序
hotpot_list.reverse()
print(hotpot_list)
#list.sort()方法 排序,与sorted()函数的功能相同,默认升序,reverse=True则为降序
#list.count(el) 查指定元素的次数,字符串中也有此方法
列表可以进行运算:
#列表的运算:+,*,in
l1=[1,2,3,4]
l2=[7,8,9,0]
l3=l1+l2
print(l3)
l4=l1*3
print(l4)
result = 3 in l1
print(result)
列表可以嵌套:
#列表的嵌套:列表中套列表
l5=[1,[1,2,3,4],[5,6],7,0]
result = [3,2] in [1,2,[3,2,1],5,6]
print(result)
el=l5[1]
print(el) #取出的结果也是列表
(3)元组
元组的特征:元组类似于列表,元组与列表都属于序列类型,但有如下区别:
- 定义元组的符号为:();
- 元组中的内容不可修改;
- 元组的关键字为:tuple;
- 元组中有一个元素也要加逗号,否责视为未加括号的元素类型。
创建元组:
t1 = ()
t2 = (1)
t3 = (1,)
print(type(t1),type(t2),type(t3))
#因为元组内容不可修改,因此不能进行增、删、改等操作,只能查。
#要将元素存入元组,可以先将元素存入列表,再用tuple()函数将列表转为元组。
#元组中元素的定位与切片与列表都是类似的操作。
#元组找最大值、最小值、求和、长度等操作也与列表相同:max\min\sum\len
元组中的一些方法:
'''
.count() 计数指定元素的个数
.index() 找出指定元素的索引位置
'''
#多变量赋值类似于元组操作
a,b,c=2,5,7 #相当于将t1=(2,5,7)然后a,b,c=t1
print(a,b,c)
#当变量个数与元组中元素个数不一致时会报错
#t5=(2,5,7)
# a,b=t5 报“过多”的错误
# a,b,c,d=t5 报“过少”的错误
#当我们如下赋值时可以避免变量过多或过少的错误
t6 = (2,5,8,9,7)
a,*b,c = t6
print(a,b,c) #变量过少,输出b为列表
a,b,*c = t6
print(a,b,c) #变量过少,输出c为列表
t7 = (4,)
a,*b = t7
print(a,b) #变量过多,输出b为空列表
# *的作用其实是拆包和装包
print(c) #输出在列表中
print(*c) #输出三个数不在列表中
print(*[4,6,8]) #输出为不带列表的4,6,8
(4)字典
字典的特征:
- 字典的符号是:{};
- 字典关键字是:dict;
- 字典保存元素的形式是键值对:key:value;
- key值在字典中是唯一的,value可以是不唯一的。
python中的字典相当于java中的高级类型Map。
定义字典:
# 定义空字典的两种方式:
dict1 = {}
dict2 = dict() #空的列表与元组也可以用这种方式定义
# 字义一个字典
dict3 = {'ID':'4334259936500','name':'lucky','age':18}
字典的增删查改:
'''
向字典中添加元素:dict8[key] = value
'''
dict8 = {}
dict8['brand'] = 'huawei'
print(dict8)
dict8['brand'] = 'mi' # 若出现同名的key,则后续定义的value覆盖原有的value
print(dict8)
dict8['type'] = 'mate30 pro'
dict8['price'] = '7200'
dict8['color'] = '紫'
'''
查找字典中的元素:字典中是没有index的,可以通过key来查找
'''
dict9 = {'1':'张三','2':'李四','3':'王五'}
print(dict9['2'])
dict10 = {'张三':100,'李四':89,'王五':97}
print(dict10['王五'])
#找分数大于90的人:字典的遍历
for key in dict10:
if dict10[key]>=90:
print(key)
print(dict10['赵飞']) # 字典中不存在该key时将会报错keyError
print(dict10.get('赵飞')) # 也是取字典中的元素,但如果取不到值,会返回None;也可以返回指定的默认值,形式为dict10.get('赵飞',99);
#in在字典中的用法
print('王五'in dict10) #判断字符串有没有在字典的key中出现
'''
删除字典中的元素:
del dict[key] #删除字典中指定键的键值对,如果指定不存在则报错
dict.pop(key) #删除指定的key的键值对,不定义key则默认删除最后一个,返回值是指定删除的键所对应的值
dict.popitem() #随机删除字典中的k-v对,但一般运行中都是从末尾删除的
dict.clear() #全部清空
'''
dict11 = {'张三':100,'李四':89,'王五':97}
del dict11['王五']
print(dict11)
result = dict11.pop('李四')
print(result)
print(dict11)
字典的方法:
'''
items() #将字典转为列表中包含元组的形式
values() #取出字典中所有的值,以列表的形式返回
keys() #取出字典中所有的键,以列表形式返回
'''
dict10 = {'张三':100,'李四':89,'王五':97}
print(dict10.items())
#因为元组是可以多变量赋值的,因此字典可以做如下遍历:
for key,value in dict10.items():
if value>=90:
print(key)
for i in dict10.items():
print(i) #这种情况是将列表中的元素,即整个元组的键值赋给了i
print(dict10.values())
print(sum(dict10.values()))
print(dict10.keys())
'''
dict_A.update(dict_B) #将dict_B合并在dict_A中,其中相同的元素将被dict_B更新掉
dict.fromkeys(seq,value) #将序列类型转为字典格式,如果不指定默认value则值为None
'''
dict12 = {'张三':100,'李四':89}
dict13 = {'李四':89,'王五':97}
result = dict12.update(dict13)
print(result)
print(dict12)
list1 = ['aa','bb','cc']
new_dict = dict.fromkeys(list1,10)
print(new_dict)
new_dict = dict.fromkeys(list1)
print(new_dict)
(5)集合
集合的特征:
- 集合是无序的不重复的元素序列;
- 集合的关键字是set;
- 集合的符号也是花括号,但其中的元素是单独存在的,而非成对出现。
创建一个集合:
# 创建空集合的方式只有一种
s1 = set()
s2 = {1,3,7} # 当里面不空的时候会被识别为集合,但空的时候会被识别为字典
#利用集合不重复的特点可以对列表去重,类型转换即可
list1 = [3,5,8,3,7,6,5]
s3 = set(list1)
print(s3)
集合的增删查改:
'''
集合的增:
set.add() #将指定的单个元素加入集合
set.update() #将序列拆成元素放入集合
'''
s1.add('hello')
s1.add('lucy')
print(s1)
t1=('林志玲','言承旭')
s1.update(t1)
print(s1)
s1.add(t1)
print(s1)
# 利用集合的set.update或set.add也可以完成对列表的去重,但比转列表类型的方法复杂,系统底层多了判断,从而占用了资源。
'''
集合的删:
set.remove(item) #删除集合中指定的元素,指定元素不存在则报错
set.dicard(item) #类似于remove,但指定元素不存在时不会报错
set.pop(item) #随机删除,但默认删除第一个元素
set.clear() #清空集合
'''
'''
其他的方法还有:.pop()、.copy()等
'''
集合的运算:
#集合的运算:交并补
set2 = {0,2,3,4,5,6}
set3 = {2,3,4,5,6}
print(set2==set3) # ==判断集合是否相同,!=也同样可以用
#集合不支持+运算,不支持*运算
# -表差集
set4 = {2,3,4,5,6,7,8,9}
set5 = set4-set3
print(set5) #减号-在集合运算中表示差集,即从被减数集中扣除与减数集中相同的部分,是有顺序的
set5 = set3.difference(set2) #此函数也表示差集,效果与-相同
# &表交集
set6 = set3 & set4
set7 = set3.intersection(set4) #此函数也表示交集
print(set6,set7)
# |表并集
set8 = set2 | set4
set9 = set2.union(set4) #此函数也表示并集
print(set8,set9)
#对称差集(补运算):两个集合中不一样的元素
l1 = [5,1,2,9,0,3]
l2 = [7,2,5,7,9]
s1 = set(l1)
s2 = set(l2)
result1 = (s1 | s2) - (s1&s2) #该方法可以求对称差集
result2 = s1 ^ s2 #异或符号在集合运算中也可以求对称差集
result3 = s1.symmetric_difference(s2) #求对称差集的函数
print(result1,result2,result3)
#求交并差并赋值:交并差对差函数后加_update 的新函数表示求交并差函数并赋值给被操作项
# 还可以使用<、<=、>、>=、in、not in等
1.2.3 类型转换
python中的自动类型转换:python的数值类型(int、float、complex)在运算时是可以自动向上转型的,这在科学计算中是非常便利的。
python中的强制类型转换:使用“type(变量名)”强制转换变量的类型。示例如下:
- int(expression)
- float(expression)
- complex(real, [,imag])
- str(expression)
- list(expression)
- dict(expression)
- set(expression)
- tuple(expression)
- repr(expression)
- chr(expression)
- ord(expression)
- hex(expression)
- oct(expression)
- eval(expression)
- 其他类型转换函数
查看变量类型:print(type(variable)),可以查看变量variable的类型。
#str类型可以转为int list set tuple
#其他类型也都可以转字符串类型
#list可以转set tuple 满足条件也可以转dict
#set tuple dict 也可转list
# 字符串转列表类型
s = 'abc'
result = list(s) #字符串会被分开输出为列表['a','b','c']
print(result)
# 可迭代表达式转列表类型list()
print(range(1,10,3)) #不能输出1,4,7,会输出range(1,10,3) # iterable表示可迭代的,可以放在for...in...中循环的都是可迭代的类型
print(list(range(1,10,3))) #可以输出1,4,7
# 列表与元组转字典:要用列表中套两个列表,元组中套两个元组,列表中套两个元组,元组中套两个列表的形式
dict4 = dict([('name','lucky'),('age',18)]) #不能只放一个元组,否则会都被识别为键而产生无值的错误
dict5 = dict((['name','lucky'],['age',18]))
dict6 = dict([['name','lucky'],['age',18]])
dict7 = dict((('name','lucky'),('age',18)))
print(dict4,'\n',dict5,'\n',dict6,'\n',dict7)
#只有双元素列表才可以转字典
# 列表转集合:利用集合不重复的特点可以去重
list1 = [3,5,8,3,7,6,5]
s3 = set(list1)
print(s3)