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～9223372036854775807long（长整型数字）跟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十进制转二进制
#1010  1*(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(':')[5])        #指定：为分隔符，取第6段

也可以指定切割次数

cmd_info='get|a.txt|333333333'        #取get这个字符串
print(cmd_info.split('|')[0])
print(cmd_info.split('|',1)[0]        #指定切割1次

c.长度len
计算字符串的长度

name='egon'
# print(name.__len__())
print(len(name))       #name.__len__()

d.切片

name='hello world'
print(name[1])
print(name[2])
print(name[3])
print(name[1:7:2])            #含头不含尾，取第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 FlaseTrue 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[2])

b.切片

my_girl_friends=['alex','wupeiqi','yuanhao',4,10,30]
print(my_girl_friends[1:3])

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数据类型）： id不变 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[1:4])

练习：简单购物车
打印商品信息，用户输入商品名和购买个数，则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入

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)

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访问（映射类型） 字典