python基础---数据类型
基本数据类型数据是用来表示状态的，不同的状态用不同的数据类型去表示
type（数据） 查看数据类型
id（数据） 查看内存地址
1、数字（int、float、complex）
作用：年纪、等级、薪资、身份证号、qq号等数字相关的
a. int(整型数字)
age=10 #age=int(10)
print(type(age))
输出：
<class 'int'>
在32位机器上，整数的位数为32位，取值范围为-2**31～2**31-1，即-2147483648～2147483647
在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
long（长整型数字）
跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。
注意：
1.自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整 数数据后面不加字母L也不会导致严重后果了
2.在Python3里不再有long类型了，全都是int
b.浮点数float
salary=3000.3 #salary=float(3000.3)
print(type(salary))
输出：
<class 'float'>
c.复数（包含实部和虚部）
x=1-2j
print(x.real) #real查看实部
print(x.imag) #imag查看虚部输出：
1.0
-2.0
d.进制之间的转换
age=10 #age=int(10)
print(bin(age)) #10->2十进制转二进制
#10101*(2**3)+1*2=10
print(oct(age)) #10->8 十进制转八进制
print(hex(age)) #10->16 十进制转十六进制
输出：
0b1010
0o12
0xa
2、字符串
作用：名字、性别、国籍、地址等描述信息
定义：在单引号/双引号/三引号，由一串字符组成
在python中，加了引号的字符都被认为是字符串（引号：单引号、双引号、三引号都可以），字符串也可以进行数学运算，但只有相加或相乘，而且字符串的拼接只能是双方都是字符串，不能跟数字或其它类型拼接
常用操作：
a.移除空白strip
name=input('username: ').strip()
print(name)或
name=input('username: ')
print(name.strip())
也可以移除其他特殊字符
name='***egon********'
print(name.strip('*'))
print(name.lstrip('*')) #移除左边的特殊字符
print(name.rstrip('*')) #移除右边的特殊字符
b.切分split
user_info='root:x:0:0::/root:/bin/bash'
print(user_info.split(':')) #指定：为分隔符，取第6段
也可以指定切割次数
cmd_info='get|a.txt|333333333' #取get这个字符串
print(cmd_info.split('|'))
print(cmd_info.split('|',1) #指定切割1次
c.长度len
计算字符串的长度
name='egon'
# print(name.__len__())
print(len(name)) #name.__len__()
d.切片
name='hello world'
print(name)
print(name)
print(name)
print(name) #含头不含尾，取第2-6个字符，指定步长为2
e.其他方法
startswith()以括号里的内容开头
endswith() 以括号里的内容结尾
name='ab_cd'
print(name.endswith('cd'))
print(name.startswith('ab'))输出：（布尔值）
True
True
replace(老的值，新的值，替换次数)替换
name='tom say :i have one tesla,my name is tom'
print(name.replace('tom','john',1))输出：
john say：i have one tesla,my name is alex
format的三种方法
print('{} {} {}'.format('egon',18,'male'))
print('{0} {1} {0}'.format('egon',18,'male'))
print('NAME:{name} AGE:{age} SEX:{sex}'.format(age=18,sex='male',name='egon'))
sdigit() 判断是否为数字
num='123'
print(num.isdigit())
输出：（返回布尔值）
True
#判断输入内容是否为数字
oldboy_age=73
while True:
age=input('>>: ').strip() #移除空格
if len(age) == 0:continue
if age.isdigit():
age=int(age)
print(age,type(age))
find() 查找字符所在的位置（下标），如果未找到字符不报错
index() 查找字符所在的位置（下标），如果未找到字符会报错
count() 统计查找的字符有多少个
默认是从左往右查找
rfind()、rindex() 从右往左查找
name='egon hello'
print(name.find('o'))
print(name.find('x'))
print(name.find('o',3,6)) #在第4到第6个之间查找字符
print(name.index('o'))
print(name.index('x'))
print(name.count('o',1,3)) #顾头不顾尾，如果不指定范围会查找所有
join() 更改分隔符
l=['egon','say','hello','world'] #类别内容必须都是字符串
print(':'.join(l))输出：
egon:say:hello:world
center() 字符居中
ljust() 字符左对齐
rjust() 字符右对齐
zfill() 字符右对齐（默认填充字符为0）
name='egon'
print(name.center(30,'*')) #指定宽度30，填充字符为*
print(name.ljust(30,'*'))
print(name.rjust(30,'*'))
print(name.zfill(30)) #填充字符为0输出：
*************egon*************
egon**************************
**************************egon
00000000000000000000000000egon
expandtabs() 指定tab键的空格数量
name='egon\thello'
print(name)
print(name.expandtabs(1))
lower() 字符全变为小写字符
upper() 字符全变为大写字符
name='EGON'
print(name.lower())
name='eg'
print(name.upper())
capitalize() 首字母大写
swapcase() 大小写翻转
title() 每个单词的首字母大写
name='egon say'
print(name.capitalize()) #首字母大写
print(name.swapcase()) #大小写翻转
msg='egon say hi'
print(msg.title()) #每个单词的首字母大写
isalnum() 判断字符串由数字和字母组成
isalpha() 判断字符串只由字母组成
name='egon123'
print(name.isalnum()) #字符串由字母和数字组成
name='egon'
print(name.isalpha()) #字符串只由字母组成
输出：（返回布尔值）
True
True
判断数字类型
num1=b'4' #Bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字
# isdigit能判断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())
3、布尔值（bool）
主要用记逻辑判断
只有两个值：
True(真)
False(假)
练习：
判断布尔值
>>>True or Flase and Flase
True
4、列表
定义：[]内可以有多个任意类型的值，使用，分割
my_girl_friends=list(['alex','wupeiqi','yuanhao',4,10,30])
可以简写为：
my_girl_friends=['alex','wupeiqi','yuanhao',4,10,30]
可以存放多个值，每个值可以对应任意一种数据类型
names=[‘alex’,’egon’,’lyndon’]
要取列表内的元素，需要通过下标，从0开始
a.索引（根据下标取）
my_girl_friends=['alex','wupeiqi','yuanhao',4,10,30]
print(my_girl_friends)
b.切片
my_girl_friends=['alex','wupeiqi','yuanhao',4,10,30]
print(my_girl_friends)
c.追加
my_girl_friends=['alex','wupeiqi','yuanhao',4,10,30]
my_girl_friends.append('oldboy')
d.删除
pop() 未指定索引的话，从最后开始删除
remove() 按照值删除
my_girl_friends=['alex','wupeiqi','yuanhao',4,10,30]
my_girl_friends.pop() #删除最后一个
my_girl_friends.pop(0) #指定索引，删除第一个
my_girl_friends.remove('yuanhao') #删除yuanhao
e.统计长度（统计的是列表内元素的个数）
my_girl_friends=['alex','wupeiqi','yuanhao',4,10,30]
my_girl_friends.__len__()
print(len(my_girl_friends))
f.in成员运算
my_girl_friends=['alex','wupeiqi','yuanhao',4,10,30]
print('wupeiqi' in my_girl_friends)输出：（返回布尔值）
True
g.插入
insert() 插入到指定位置之前
my_girl_friends=['alex','wupeiqi','alex','yuanhao',4,10,30]
my_girl_friends.insert(1,'Sb')
其他操作：
clear() 清除列表内容
copy() 复制列表内容到新的列表
count() 统计列表内元素的个数
extend() 一次添加多个元素
index() 查看元素下标
reverse() 翻转列表
sort() 从小到大排序
#队列：先进先出
方法一：
使用append追加，使用pop从第一个开始取
fifo=[]
#入队
fifo.append('first')
fifo.append('second')
fifo.append('third')
print(fifo)
#出队
print(fifo.pop(0))
print(fifo.pop(0))
print(fifo.pop(0))
方法二：
使用insert插入元素到第一，这样后插入的元素就排在前面，然后使用pop默认从最后一个开始取
#入队
# fifo.insert(0,'first')
# fifo.insert(0,'second')
# fifo.insert(0,'third')
# print(fifo)
#
# #出队
# print(fifo.pop())
# print(fifo.pop())
# print(fifo.pop())
#堆栈：先进后出
5、字典
作用：存多个值，key-value存取，取值速度快，字典内的键值对是无序的，不能使用下标取值
定义：key必须是不可改变类型，也成为可hash类型，value可以是任意类型，不可变的数据类型都可以当做字典的key
info={'name':'egon','age':18,'sex':'male'}
#本质
info=dict({'name':'egon','age':18,'sex':'male'})
采用key:value的方式存储值，可以存放多个值
dic={‘name’:’egon’,’passwd’:123} 字典通过key来取value
可变数据类型（或称为不可hash数据类型）：
> type不变
值变了
列表属于可变类型，数字和字符串都是不可变类型
a.存/取
info={'name':'egon','age':18,'sex':'male'}
print(info['age']) #取出key为age的value值
print（info.get(‘age’)） #根据key取value值，如果不存在不会报错
info['height']=1.80 #存入一个key=height,value=1.80的元素
b.删除
pop(key,none) 按照key删除,如果key不存在，则显示none，不会抛出异常
info={'name':'egon','age':18,'sex':'male'}
print(info.pop('name'))
print(info.pop('asdfsadfasdfasfasdfasdfasdf',None))
其他方法：
popitem() 会随机的删除字典中的一个键值对
keys() 会取出字典中所有的key
values() 会取出字典中所有的value
items() 会把字典以一个列表的形式打印出来，字典中的元素以列表中的元组表示
copy() 复制到一个新字典
clear() 清空字典
info={'name':'egon','age':18,'sex':'male'}
print(info.popitem()) #随机删除字典中的一个键值对
print(info.keys()) #取出字典中所有的key
print(info.values()) #取出字典中所有value
print(info.items())
for key,value in info.items(): # key,value=('name','egon')
print(key,value)
fromkeys(keys,value) keys用列表的形式，列表内为多个key，一个value对应多个key
info={'name':'egon','age':18,'sex':'male'}
dic=info.fromkeys(['name','age','sex'],11111111)
输出：
{'name': 11111111, 'age': 11111111, 'sex': 11111111}
老字典.update(新字典) 用新的字典更新老的字典
setdefault() 一个key使用列表的方式储存多个vaule值
d={}
d.setdefault('hobby',[]).append('play1') #d['hobby']
d.setdefault('hobby',[]).append('play2') #d['hobby']
d.setdefault('hobby',[]).append('play3') #d['hobby']
print(d)
输出：
{'hobby': ['play1', 'play2', 'play3']}
6、元组
作用：存多个值，相当于一个元素不可改变的列表，主要用于读
定义：使用()进行定义，可以当做字典的key
a.索引
index() 根据下标取值
age=(11,22,33,44,55,33)# 本质age=tuple((11,22,33,44,55))
print(age.index(33))
b.长度
len() 计算长度
count() 统计元素的个数
age=(11,22,33,44,55,33)
print(len(age))
print(age.count(33))
c.切片
age=(11,22,33,44,55,33)
print(age)
练习：简单购物车
打印商品信息，用户输入商品名和购买个数，则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入
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))
print('\033,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,int(count)))
print(goods_l)
7、集合
作用：去重，关系运算
定义：由不同元素组成的集合，集合中是一组无序排列的可hash值（也就是集合内的值都是不可变数据类型），集合内的元素唯一，可以作为字典的key，集合的目的是将不同的值存放在一起，不同的集合之间用来做关系运算，无需纠结于集合的单个值
a.成员运算
in 和 not in
结果返回布尔值
b.关系运算
& 交集
| 并集
- 差集
^ 对称差集
>= 父集
<= 子集
父集、子集会返回布尔值
# 关系运算
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)
c.增/删
add() 增加元素（必须是不可变类型）
pop() 删除元素（随机删）
remove() 删除元素（指定元素名，元素不存在会报错）
discard() 删除元素（指定元素名，元素不存在不会报错）
d.方法
使用方法来表示各种集合
intersection 交集
union 并集
difference 差集
symmetric_difference 对称差集
总结：
按存值个数区分
标量／原子类型:数字，字符串
容器类型:列表，元组，字典
按可变不可变区分
可变:列表，字典
不可变:数字，字符串，元组
按访问方式区分
直接访问：数字
按照索引访问（序列类型）：字符串，列表，元组
key访问（映射类型） 字典
页:
[1]