Python 基本数据类型

1 整型 int

2 浮点型 float

3 字符串 str

4 列表 list

5 元组 tuple

6 字典类型 dict

7 布尔 bool

8 复数

9 可变类型和不可变类型

---

 

基本数据类型

2.5.1 整型 int

长整型：python2中 x=3L

状态：等级，身份证号，年龄

>>> level=10    #level=int(10)
>>> print(level,type(level),id(level))

2.5.2 浮点型 float

只能存一个值,不可变

状态：薪资，身高，体重

>>> salary=3000.3   #salary=float(3000.3)
>>> print(salary,type(salary),id(salary))

2.5.3 字符串 str

只有一个值，子字符串有序，不可变（值变，id就变。不可变==可hash）

在引号（单引号，双引号，三引号）里定义的一堆字符

状态：描述性的内容，比如名字，性别，国籍

单引号

>>> gender='male'    #gender=str('male')
>>>  print(type(gender))

双引号

>>>  info="my name is egon i'm a teacher"

三引号

>>> msg='''
>>> xxxx
>>> yyy
>>> zzz
>>> '''
>>> print(msg)

>>>  x=1
>>>  y=2.3
>>>  res=x+y
>>>  print(res)

字符只能跟字符串之间进行+或者*

>>> info1='hello'
>>> nfo2='world'
>>> res=info1+info2
>>> print(res)
 
>>> print('egon'*10)
>>> print(''*10)   #输出结果egonegonegonegonegonegonegonegonegonegon

 
>>>  print('='*10)
>>>  print('hello world')
>>>  print('='*10)
输出结果：==========
         hello world
         ==========

常用方法：

msg='hello world'

1、按索引取值(正向取+反向取) ：只能取

print(msg[0],type(msg[0])) #正向取
print(msg[-1]) #反响取

2、切片(顾头不顾尾，步长)

print(msg[0:3]) #>=0 <3
print(msg[0:7]) #>=0 <7
print(msg[0:7:1]) #>=0 <7
print(msg[0:7:2]) #hlow
print(msg[:]) #全部输出
print(msg[5:1:-1]) # oll
print(msg[-1::-1]) #倒序取全部

3、长度len

print(msg.__len__())
print(len(msg)) #msg.__len__()

4、成员运算in和not in

msg='hello world'
print('llo' in msg) #True
print('llo' not in msg) #False

5、移除空白strip,lstrip,rstrip

print("**alex****".strip('*'))
print("**alex****".lstrip('*'))
print("**alex****".rstrip('*'))

6、切分split，rsplit

user_info='root:x:0:0::/root:/bin/bash'
res=user_info.split(':')
print(res[0])

cmd='get /root/a/b/c/d.txt'
print(cmd.split())

file_path='C:\a\d.txt'
print(file_path.split('\',1)) #切分一次

file_path='C:\a\d.txt'
print(file_path.rsplit('\',1))#右侧切分一次

7、循环

msg='hel'
for i in msg:
    print(i)

8、小写lower,大写upper

print('ALeX'.lower())
print('aaa'.upper())

10、startswith,endswith

msg='alex is SB'
print(msg.startswith('alex'))
print(msg.startswith('a'))
print(msg.endswith('SB'))

11、format的三种玩法

print('my name is %s my age is %s' %('alex',18))
# 第一种：
print('my name is {} my age is {}'.format('alex',18))
print('my name is {} my age is {}'.format(18,'alex'))
#第二种：
print('{0} {1} {0}'.format('alex',18))
#第三种：
print('my name is {name} my age is {age}'.format(age=18,name='male'))

12、join

print(':'.join(l)) #l是列表
l=[1,2,3]
# ' '.join(l) #报错：只有在列表内的元素全是字符串类型，才能用join拼接

13、replace

msg='alex say my name is alex ,alex have on tesla'
msg=msg.replace('alex','SB',1)#替换1个
print(msg)

14、isdigit

age=input('>>: ').strip()
if age.isdigit():
     age=int(age)
else:
     print('必须输入数字')

了解：

#1、find,rfind,index,rindex,count
msg='hello world'
print(msg.find('wo'))
print(msg.find('SB')) #找不到不会报错

print(msg.index('wo'))
print(msg.index('SB')) #ValueError: substring not found

print(msg.count('l'))
print(msg.count('SB')) #统计字符串出现的次数
#2、center,ljust,rjust,zfill
print('egon'.center(30,'*'))#中间对齐，两侧用*填充
print('egon'.ljust(30,'*'))#左对齐，右侧用*填充
print('egon'.rjust(30,'*'))#右对齐，左侧用*填充
print('egon'.zfill(30))#右对齐，左侧填充0

#3、expandtabs
print('hello	world'.expandtabs(10))#把tab替换未空格
#4、captalize,swapcase,title
print('i am egon'.capitalize())#这句话首字母大写
print('i am egon'.title()) #每个单词首字母大写
print('AbC'.swapcase()) #取反，大写换成小写，小写换成大写
#5、is数字系列isdigit，isdecimal，isnumeric
num1=b'4'  #bytes
num2=u'4'  #unicode,python3中无需加u就是unicode
num3='壹'  #中文数字
num4='Ⅳ'  #罗马数字
#bytes,unicode
print(num1.isdigit())#True
print(num2.isdigit())#True
print(num3.isdigit())#False
print(num4.isdigit())#False
#unicode
print(num2.isdecimal())#True
print(num3.isdecimal())#False
print(num4.isdecimal())#False
#unicode，中文，罗马
print(num2.isnumeric())#True
print(num3.isnumeric())#True
print(num4.isnumeric())#True
#6、is其他isalnum，isalpha，isidentifier ，islower，isupper，isspace，istitle
name='egon123'
print(name.isalnum()) #True字符串由字母或数字组成
print(name.isalpha()) #False字符串只由字母组成

print('print1111'.isidentifier()) #True是否含关键字
print('abcA'.islower()) #False是否都是小写
print(name.isupper()) #False是否都是大写
print(' '.isspace()) #True是否是空格
print('Am Ia'.istitle()) #True是否单词首字母大写

 

2.5.4 列表 list

多个值，任意类型，有序，可变（值变，id不变。可变==不可hash）

在[]内，用逗号分隔开，存放多个任意类型的元素

状态：有序存放多个值

print(list('hello')) #结果['h', 'e', 'l', 'l', 'o']

列表里可以存放列表

>>> info=['egon',18,'male',['欧德博爱','education',70]] #info=list([...])=
>>> print(info[0])
>>> print(info[3])
>>> print(info[3][0])'''

常用操作：

my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
#1、按索引存取值(正向存取+反向存取)：即可存也可以取
my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
#2、切片(顾头不顾尾，步长)同字符串操作
#3、长度
print(my_girl_friends.__len__())
print(len(my_girl_friends))
#4、成员运算in和not in
print('wupeiqi' in my_girl_friends)
#5、追加 append
my_girl_friends[5]=3 #IndexError: list assignment index out of range
my_girl_friends.append(6)
print(my_girl_friends)
#6、删除 del,remove,pop
my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
#单纯的删除del,remove
del my_girl_friends[0]
print(my_girl_friends)

res=my_girl_friends.remove('yuanhao')
print(my_girl_friends)
print(res)
print(my_girl_friends)
 
#删除并拿到结果:取走一个值pop
res=my_girl_friends.pop(2) #可以指定删除的序列号
res=my_girl_friends.pop() #默认删除最后一个
print(res)
#7、循环
my_girl_friends=['alex','wupeiqi','yuanhao',4,5]
for item in my_girl_friends:
     print(item)
#8、insert
my_girl_friends=['alex','wupeiqi','yuanhao','yuanhao',4,5]
my_girl_friends.insert(1,'egon') #插入
print(my_girl_friends)
#9、clear
my_girl_friends.clear()#清空
print(my_girl_friends)
#10、copy
l=my_girl_friends.copy()#复制
print(l)
#11、count
 print(my_girl_friends.count('yuanhao'))#统计出现的次数
#12、extend
l=['egon1','egon2']
my_girl_friends.extend(l) #合并两个列表
my_girl_friends.extend('hello')
print(my_girl_friends)
#13、index
my_girl_friends=['alex','wupeiqi','yuanhao','yuanhao',4,5]
print(my_girl_friends.index('wupeiqi'))#找索引
print(my_girl_friends.index('wupeiqissssss'))
#14、reverse
my_girl_friends=['alex','wupeiqi','yuanhao','yuanhao',4,5]
m=my_girl_friends.reverse()#反取
print(m)
#15、sort
l=[1,10,4,11,2,]
l.sort()  #排序递增
l.sort(reverse=True)  #排序递减
print(l)
#比较>
x='healloworld'
y='he2'
print(x > y)#按ASCII表排序

l=['egon','alex','wupei']
l.sort()
# print(l)

2.5.5 元组 tuple

多个值，任意类型，有序，不可变(值变，id就变。不可变==可hash)

定义在小括号内，用逗号分隔，存放任意类型多个值, 就是说你不能更新或者改变元组的元素

只有一个元素的元组需要在元组分割符里面加一个逗号(,)用以防止跟普通的分组操作符混淆，如(1,)

定义：与列表类型比，只不过[]换成()

age=(11,22,33,44,55)  #本质age=tuple((11,22,33,44,55))
print(type(age))
age[0]=12

元组可以存放可变元素

t=(1,2,['a','b'])
print(id(t[2])) #37962376
t[2][0]='A'
print(id(t[2])) #37962376 id未变
print(t) #(1, 2, ['A', 'b'])

优先掌握的操作：

#1、按索引取值(正向取+反向取)：只能取
#2、切片(顾头不顾尾，步长)
age=(11,22,33,44,55)
print(age[0:3])
print(age)
#3、长度
age=(11,22,33,44,55)
print(len(age))
#4、成员运算in和not in
age=(11,22,33,44,55)
print(11 in age)
#5、循环
for item in age:
    print(item)
#6、count
print(age.count(33))
#7、index
age=(11,22,33,44,55)
print(age.index(33)) #取索引
print(age.index(33333))

2.5.6 字典类型 dict

多个值，key不可变，无序，可变类型(值变，id不变。可变==不可hash)

定义花括号内，用逗号分割key : value，value可以是任意类型，但是key必须不可变类型

状态：存放多个值

>>> #  name  age  sex   company
>>> info=['egon',18,'male',['欧德博爱','education',70]]
>>>info[2]
 
>>> #  name  age  sex   company
>>> info={
>>>    'name':'egon',
>>>    'age':18,
>>>    'sex':'male',
>>>    'company':['欧德博爱','education',70]
>>> }         #info=dict({....})
>>> print(info,type(info),id(info))

>>> print(info['sex'])
>>> print(info['company'][2])

字典里可以含字典

>>> info={
>>>    'name':'egon',
>>>    'age':18,
>>>    'sex':'male',
>>>    'company':{'name':'欧德博爱','type':'education','emp_count':70}
>>> }
>>> print(info['company']['type'])

>>> dic={0:'egon',1:'xxx',2:'yyy'}
>>> print(dic[0])

>>> stduents=['egon','alex','wxx','yxx']

了解字典多个定义方法

#第一种
info=dict(age=18,sex='male',name='egon')
print(info)
#第二种
info=dict([('name','egon'),('age',18),('sex','male')])
info=dict([['name','egon'],['age',18],['sex','male']])
print(info)
#第三种
info={}.fromkeys(['name','age','sex'],None)
info={}.fromkeys('hello',None)
print(info)

优先掌握的操作：

#1、按key存取值：可存可取
d={'name':'egon'}
print(d['name'])

d['age']=18
print(d)
#2、长度len
info={'name':'egon','age':18,'sex':'male'}
print(len(info))
#3、成员运算in和not in
info={'name':'egon','age':18,'sex':'male'}
print('name' in info)
#4、删除pop
info={'name':'egon','age':18,'sex':'male'}
print(info.pop('name'))#用key删除
print(info)
print(info.popitem()) #('sex', 'male')用key,value删除
print(info.pop('name1',None))#存在返回values值，不存在返回“没有”
print(info)
#5、键keys()，值values()，键值对items()
print(info.keys())
print(list(info.keys())[0])
print(list(info.values()))
print(list(info.items()))#取键值对
#6、循环
info={'name':'egon','age':18,'sex':'male'}
for k in info:
    print(k,info[k])

其他需要掌握的方法

#1、get
info={'name':'egon','age':18,'sex':'male'}
print(info['hobbies'])
print(info.get('hobbies','没有'))#如果key存在返回values值，不存在返回“没有”
#2、update
d={'x':1,'y':2,'name':'EGON'}
info.update(d)#info信息更新
print(info)
#3、setdefault
info={'name':'egon','age':16,'sex':'male'}
value=info.setdefault('age',18) #如果key存在，则不修改，返回已经有的key对应的value
print(value)
print(info)
#Low方法一
info={'name':'egon',}
info['hobbies']=[]
info['hobbies'].append('music')
info['hobbies'].append('read')
print(info)
#Low方法二
info={'name':'egon',}
if 'hobbies' not in info:
    info['hobbies']=[]
else:
    info['hobbies'].append('music')
#方法三 运用setdefault
hobbies_list=info.setdefault('hobbies',[])
print(hobbies_list)
hobbies_list.append('play')
hobbies_list.append('read')

print(info)

2.5.7 布尔 bool

布尔值：True, False

状态：成立，不成立，用来做逻辑运算 ---> 判断

>>> print(type(True))

>>> age=38
>>> print(age > 18)

2.5.8 复数

x=1+2j
print(x.real)  #打印实部
print(x.imag)  #打印虚部
print(type(x))

2.5.9 可变类型和不可变类型

可变类型：在id不变的情况下，value可以变，则称为可变类型，如列表，字典

不可变类型：value一旦改变，id也改变，则称为不可变类型（id变，意味着创建了新的内存空间）如：int, float, str，bool

>>>  dic={1:'a'}
>>>  dic={1.1:'a'}
>>>  dic={'b':'a'}

>>>  dic={[1,2,3]:'a'}  #会报错
>>>  dic={{'a':1}:'a'}  #会报错

>>>  dic={True:'a'}
>>>  print(dic[True])