第二篇：数据类型
1、数字
包括整形，长整形，浮点型，复数
作用：年纪，等级，薪资，身份证号，qq号等数字相关
整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。
浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
Python 数字类型转换
有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
-
int(x) 将x转换为一个整数。
-
float(x) 将x转换到一个浮点数。
-
complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
-
complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。
int(x [,base]) 将x转换为一个整数 float(x ) 将x转换到一个浮点数 complex(real [,imag]) 创建一个复数 str(x) 将对象x转换为字符串 repr(x) 将对象x转换为表达式字符串 eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象 tuple(s) 将序列s转换为一个元组 list(s) 将序列s转换为一个列表 chr(x) 将一个整数转换为一个字符 unichr(x) 将一个整数转换为Unicode字符 ord(x) 将一个字符转换为它的整数值 hex(x) 将一个整数转换为一个十六进制字符串 oct(x) 将一个整数转换为一个八进制字符串
2、字符串
作用：名字，性别，国籍，地址等描述信息
定义：在单引号\双引号\三引号内，由一串字符组成
创建字符串很简单，只要为变量分配一个值即可。例如：
>>> name='jun xun' >>> var="hello world!" >>> print(name) jun xun >>> print(var) hello world!
字符串常用操作如下：
2.1 移除空白strip
name=input('please you name: ')
print(name)
执行上面代码后
如上，输入空格后再输入姓名，会将空格也打印出来，要想输入空格后打印的不包含空格就需要进行移除空白操作了
name=input('please you name: ')
name=name.strip()
print(name)
上面的代码简化后操作
name=input('please you name: ').strip()
print(name)
也可写成如下操作代码
name=input('please you name: ')
print(name.strip())
2.2 切分split
示例1：
user_info='root:x:0:0::/root:/bin/bash'
print(user_info.split(':')[5])
#注释：
这里user_info为变量名
split为切割参数
(':')以:为切割符
[5] 取变量名user_info以：切割后的下标为5的字符串
示例2：
cmd_info='get|a.txt|33333333'
print(cmd_info.split('|')[0])
2.3 长度len
取出字符串里面字符串的长度
name='junxun' print(name.__len__())
name='junxun' print(len(name))
注释：
这里len(name)相当于name.__len__()
2.4 切片
name='hello world' print(name[1:4])
执行上述代码结果如下，
2.5其它重要参数
#endswith 判断字符串以什么为结尾
name='jun_xun'
print(name.endswith('xun')) #判断变量name值的字符串是否以xun结尾
#startswith 判断字符串是否以什么为开头
name='jun_xun'
print(name.startswith('jun')) #判断变量name值的字符串是否以jun为开头
#replace 1.2.7 字符串替换
name='jun say :i have one tesla,my name is jun'
print(name.replace('jun','xun',1)) #将字符串jun替换成xun，只替换1次
#字符串format格式化输出
print('{},{},{}'.format('jun',18,'xun'))
#isdigit 判断字符串里是否只有数字
num='123'
print(num.isdigit())
#find 查找字符串以下标（find），查找找不到的不会报错，显示-1
name="junxun hello"
print(name.find('x')) #打印字母x的下标
print(name.find('b')) #打印字母b的下标，不存在会显示-1
print(name.find('o',3,6)) #打印从下标3到下标6之间的字母o，不存在会显示-1
#index 查找字符串以下标（index），查找找不到的会报错
name='junxun hello'
print(name.index('x')) #打印字母x的下标
print(name.index('b')) #打印字母b的下标，不存在报错
#count 显示字符串中字母出现的次数（count）
name='junxun hello'
print(name.count('u')) #显示字母出现u的次数
print(name.count('u',0,3)) #显示下标0到3之间字母出现的次数
2.6 其它了解参数
b=['junxun','say','hello'] #类别内容必须都是字符串
print(':'.join(b))
name='junxun'
print(name.center(30,'*'))
print(name.ljust(30,'*'))
print(name.rjust(30,'*'))
print(name.zfill(30))
name='ning\thello'
print(name)
print(name.expandtabs(1))
name='JUN'
print(name.lower())
name='jun'
print(name.upper())
name='ning say'
print(name.capitalize()) #首字母大写
print(name.swapcase()) #大小写翻转
msg='ning say hi'
print(msg.title()) #每个单词的首字母大写
name='ning123'
print(name.isalnum()) #字符串由字母和数字组成
name='ning'
print(name.isalpha()) #字符串只由字母组成
num1=b'4' #Bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字
# bytes,unicode
print(num1.isdigit())
print(num2.isdigit())
print(num3.isdigit())
print(num4.isdigit())
# isdecimal:unicode
print(num2.isdecimal())
print(num3.isdecimal())
print(num4.isdecimal())
# isnumberic:unicode,汉字，罗马
print(num2.isnumeric())
print(num3.isnumeric())
print(num4.isnumeric())
2.7 python字符串运算符
下表实例变量a值为字符串 "Hello"，b变量值为 "Python"：
3、 列表
作用：多个装备，多个爱好，多门课程，多个女朋友等
定义：[]内可以有多个任意类型的值，逗号分隔
my_girl_friends=['ning','jun','linux','python',3,5,7]
# my_girl_friends=list(['ning','jun','linux','python',3,5,7])
# print(type(my_girl_friends))
# print(my_girl_friends[2])
#
# print(my_girl_friends[1:3])
# my_girl_friends.append('mysql')
# print(my_girl_friends)
#pop按照索引
# my_girl_friends.pop()
# my_girl_friends.pop()
# my_girl_friends.pop(0)
# my_girl_friends.pop(0)
# my_girl_friends.pop(1)
#remove按照值
# my_girl_friends.remove('ning')
# print(my_girl_friends)
# my_girl_friends.__len__()
# print(len(my_girl_friends))
# print('ning' in my_girl_friends)
#
# msg='my name is jun111111'
# print('jun' in msg)
#其他操作（掌握）
# my_girl_friends=['ning','jun','linux','python',3,5,7]
# my_girl_friends.insert(1,'mysql')
# print(my_girl_friends)
#其他操作（了解）
my_girl_friends=['ning','jun','linux','ning','python',3,5,7]
# my_girl_friends.clear()
# print(my_girl_friends)
# l=my_girl_friends.copy()
# print(l)
# print(my_girl_friends.count('ning'))
# my_girl_friends.append('vpn1')
# my_girl_friends.append('vpn2')
# my_girl_friends.append('vpn3')
# print(my_girl_friends)
# my_girl_friends.extend(['vpn1','vpn2','vpn3'])
# print(my_girl_friends)
# print(my_girl_friends.index('ning'))
# my_girl_friends.reverse()
# print(my_girl_friends)
# l=[3,-1,5,2]
# l.sort(reverse=True)
# print(l)
#练习一：
data=['ning',18,[1999,3,25]]
# print(data[0])
# print(data[1])
# print(data[2][0])
# name,age,birth=data
# print(name)
# print(age)
# print(birth)
#
#
# msg='hello'
# a,b,c,d,e=msg
# print(a,b,c,d,e)
# msg='hello'
# a,_,_,_,b=msg
# print(a)
# print(b)
# a,*_,b=msg
# print(a,b)
#队列：先进先出
fifo=[]
#入队
# fifo.append('first')
# fifo.append('second')
# fifo.append('third')
# print(fifo)
# #出队
# print(fifo.pop(0))
# print(fifo.pop(0))
# print(fifo.pop(0))
#入队
# fifo.insert(0,'first')
# fifo.insert(0,'second')
# fifo.insert(0,'third')
# print(fifo)
#
# #出队
# print(fifo.pop())
# print(fifo.pop())
# print(fifo.pop())
#堆栈：先进后出
lifo=[]
4、元组
作用：存多个值，对比列表来说，元组不可变，主要是用来读
定义：与列表类型，只不过[]换成()
可以当做字典的key
age=(11,22,33,44,55)本质age=tuple((11,22,33,44,55))
Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
如下实例：
tup1 = ('Google', 'Runoob', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d";
创建空元组
tup1 = ();
元组与字符串类似，下标索引从0开始，可以进行截取，组合等。
元组使用方法：
age=(11,22,33,44,55,33)# 本质age=tuple((11,22,33,44,55))
# print(age[2])
# print(age[1:4])
# print(len(age))
#
# print(11 in age)
# print(age.index(33))
# print(age.count(33))
#元组练习：简单购物车
#实现打印商品详细信息，用户输入商品名和购买个数，则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
goods_l=[]
while True:
for key in msg_dic:
# print('Goods Name:%s Price:%s' %(key,msg_dic[key]))
print('\033[43mName:{name} Price:{price}\033[0m'.format(price=msg_dic[key],name=key))
choice=input('your goods name>>: ').strip()
if len(choice) == 0 or choice not in msg_dic:continue
count=input('your count>>: ').strip()
if count.isdigit():
goods_l.append((choice,msg_dic[choice],int(count)))
print(goods_l)
5、字典
作用：存多个值,key-value存取，取值速度快
定义：key必须是不可变类型，value可以是任意类型
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
一个简单的字典实例：
dict = {'ning': '2341', 'jun': '9102', 'xun': '3258'}
也可如此创建字典：
dict1={'abc':456}
dict2={'abc':123,95.5:24}
字典使用方法
info={'name':'ning','age':18,'sex':'male'}
#本质info=dict({'name':'ning','age':18,'sex':'male'})
# print(info['age'])
# info['height']=1.80
#
# print(info)
#
# for key in info:
# print(key)
#字典的key必须是不可变类型，也成为可hash类型
# info={(1,2):'a'}
# print(info[(1,2)])
#字典常用的方法(优先掌握)
info={'name':'ning','age':18,'sex':'male'}
# print(info.pop('name'))
# print(info)
# print(info.pop('aasdffasdfasfgagfsgasf',None))
# print(info['name1'])
# print(info.get('name1'))
# print(info.get('sdafffkgasdasafs','not key'))
#字典其他的方法
info={'name':'ning','age':18,'sex':'male'}
# print(info.popitem())
# print(info.popitem())
# print(info)
#
# print(info.keys(),type(info.keys()))
# print(info.values())
# for key in info.keys():
# print(key)
# for key in info.values():
# print(key)
# for key in info:
# print(key,info[key])
# print(info.items())
# for key,value in info.items(): # key,value=('name','ning')
# print(key,value)
# msg_dic={
# 'apple':10,
# 'tesla':100000,
# 'mac':3000,
# 'lenovo':30000,
# 'chicken':10,
# }
# for key,value in msg_dic.items():
# print(key,value)
# info={'name':'ning','age':18,'sex':'male'}
# info.clear()
# print(info)
# print(info.items())
# dic=info.fromkeys(['name','age','sex'],11111111)
# print(dic)
#
# dic=info.fromkeys(['name','age','sex'],None)
# print(dic)
#
# dic=dict(a=1,b=2,c=3)
# print(dic)
# print(info.items())
# print(dict([('name', 'ning'), ('age', 18), ('sex', 'male')]))
# dic=dict.fromkeys(['name','age','sex'],11111111)
# print(dic)
# print(info)
# print(info)
# dic={'a':1,'b':2,'name':'SHUAI'}
# info.update(dic)
# print(info)
# d=dict.setdefault(['a','b','c'],[])
# print(d)
#
# d={}
# print(d)
# d['name']='ning'
# d['age']=18
# d['sex']='male'
# # d['hobby']=[]
# # d['hobby'].append('play basketball')
# # d['hobby'].append('play football')
#
# d.setdefault('hobby',[]).append('play1') #d['hobby']
# d.setdefault('hobby',[]).append('play2') #d['hobby']
# d.setdefault('hobby',[]).append('play3') #d['hobby']
# print(d)
#字典练习
# nums=[11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
# dic={
# 'k1':[],
# 'k2':[],
# }
# for item in nums:
# if item >= 66:
# dic['k1'].append(item)
# else:
# dic['k2'].append(item)
#
# print(dic)
s='hello ning ning say hello python python'
words=s.split()
# print(words)
dic={}
for word in words:
# print(word)
if word not in dic:
dic[word]=1
#{'hello':1,'ning':1}
else:
dic[word]+=1
print(dic)
6、集合
作用：去重，关系运算，
定义：由不同元素组成的集合，集合中是一组无序排列的可hash值，可以作为字典的key
集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值
集合使用方法
# pythons=['ning','jun','xun','linux','mysql','nginx']
# linuxs=['ning','nginx','git']
#
# res=[]
# for p in pythons:
# if p in linuxs:
# res.append(p)
#
# print(res)
#关系运算？？？
#1 集合内可以有多个元素，但是每个元素都必须是不可变类型，即可hash类型
#2 集合内的元素唯一
#3 集合是无序的
# s={1,'a',1,1,1,1,1,1} #s=set({1,'a',1,1,1,1,1,1})
# s1=set('hello')
# print(s1,type(s1))
# s={'a',3,9,'b'}
# print(s)
#集合优先掌握的方法
# pythons={'ning','jun','xun','linux','mysql','nginx'}
# print('ning' not in pythons)
# print(pythons)
# print('mysql' not in pythons)
# print(pythons)
#关系运算
# s1={1,10,11,22}
# s2={1,11,33}
#交集
# print(s1 & s2)
#并集
# print(s1 | s2)
#差集
# print(s1 - s2)
# print(s2 - s1)
#对称差集
# print(s1 ^ s2)
#父集
# s1={1,2,3,4}
# s2={1,5}
# print(s1 >= s2)
#
# #子集
# print(s1 <= s2)
# print(s2 <= s1)
#集合练习一
# pythons=['ning','jun','xun','linux','mysql','nginx']
# linuxs=['ning','nginx','git']
#
#
# # 1. 求出即报名python又报名linux课程的学员名字集合
# print(pythons & linuxs)
# # 2. 求出所有报名的学生名字集合
# print(pythons | linuxs)
# # 3. 求出只报名python课程的学员名字
# print(pythons - linuxs)
# # 4. 求出没有同时这两门课程的学员名字集合
# print(pythons ^ linuxs)
#集合练习二：
# 1. 有列表l=['a','b',1,'a','a']，列表元素均为可hash类型，去重，得到新列表,且新列表无需保持列表原来的顺序
# l=['a','b',1,'a','a']
#
# s=set(l)
# print(s)
# print(list(s)
# )
# 2.在上题的基础上，保存列表原来的顺序
# l=['a','b',1,'a','a']
#
# l1=[]
# for item in l:
# if item not in l1:
# l1.append(item)
# print(l1)
#
# l1=[]
# s=set()
# for item in l:
# if item not in s:
# s.add(item) #{'a','b',1}
# # l1.append(item)
# l1.append(item)
#
# print(l1)
#
# 4.有如下列表，列表元素为不可hash类型，去重，得到新列表，且新列表一定要保持列表原来的顺序
#
# l=[
# {'name':'ning','age':18,'sex':'male'},
# {'name':'jun','age':73,'sex':'male'},
# {'name':'ning','age':20,'sex':'female'},
# {'name':'ning','age':18,'sex':'male'},
# {'name':'ning','age':18,'sex':'male'},
# ]
#
# l1=[]
# for item in l:
# if item not in l1:
# l1.append(item)
# print(l1)
# l1=[]
# s=set()
# for item in l:
# val=(item['name'],item['age'],item['sex'])
# # print(val)
# if val not in s:
# s.add(val)
# # print(val)
# l1.append(item)
#
# print(l1)
#集合的内置方法
# pythons=['ning','jun','xun','linux','mysql','nginx']
# linuxs=['ning','nginx','git']
# 1. 求出即报名python又报名linux课程的学员名字集合
# print(pythons & linuxs)
# print(pythons.intersection(linuxs))
# 2. 求出所有报名的学生名字集合
# print(pythons | linuxs)
# print(pythons.union(linuxs))
# 3. 求出只报名python课程的学员名字
# print(pythons - linuxs)
# print(pythons.difference(linuxs))
# 4. 求出没有同时这两门课程的学员名字集合
# print(pythons ^ linuxs)
# print(pythons.symmetric_difference(linuxs))
s={1,2,3,'a'}
# s.add(4)
# print(s)
# print(s.pop())
# s.remove('a')
# print(s)
# s.remove('vvvvvvvvvv')
# s.discard('aaaaaa')
# print(s)
