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十进制转二进制
#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 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[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访问（映射类型）    字典

转载于:https://blog.51cto.com/lyndon/1946066