python语言基础-1语法基础-1.2 数据类型

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)