python 基本数据类型

1. number

1.1 整型(int)

• 作用：年纪，等级，身份证号，qq号等整型数字相关
• 定义：
  age=10 #本质age=int(10)

1.2 浮点型

• 作用：薪资，身高，体重，体质参数等浮点数相关
  salary=3000.3 #本质salary=float(3000.3)

2. 字符串 str

• 作用：对事物的具体描述信息
• 定义：在单/双/三引号中由一串字符组成
• 相关操作

例：a='I love you'
(1)按索引取值(从0开始)   print(a[2])  #l

(2)切片(顾头不顾尾，步长,最后一位是-1） 
print(a[2:4])  # lo
print(a[0:-1]) #I love yo
print(a[0:-1:2]) #Ilv o
print(a[::-2]) # uyeo 

(3)长度 print(len(a) #10

(4)成员运算in,not in 返回true或者false

(5)移除空白strip
name='****A*e*gon****'
print(stript.name('*') #A*e*gon
print(lstript.name('*') 去除左边* #A*e*gon****
print(rstrip.name('*') 去除右边*  #****A*e*gon

(6)切分split(切分符号，个数)
msg='egon:18:male:180:160'
l=msg.split(':')
print(l)
#['egon', '18', 'male', '180', '160']
从右边切分
print(msg.rsplit(':',1))
#['egon:18:male:180', '160']

(7) 大小写 upper,lower

(8)startswith,endswith 以什么开头/结尾,返回true或者false
print('I love you'.startswith('I')) # true

(9)format 三种用法
print('my name is {name} my age is {age}'.format(age=18,name='egon')) # 可以打破位置的限制,但仍能指名道姓地为指定的参数传值
print('my name is {} my age is {}'.format('egon',18))
print('my name is {0}{0} my age is {1} {1} {1} {1}'.format('egon',18))

(10)join 拼接
用指定符号拼接
info='qqc:18:male'
print('-',join(info) 
#q-q-c-:-1-8-:-m-a-l-e
将元素全为字符串的列表拼成一个大的字符串
info= ['ggh','jh','drt','kit']
print('|'.join(info))
#ggh|jh|drt|kit

(11) replace 替换
a='I love you I'
print(a.replace('I','gg') 
#gg love you gg
可指定替换个数(默认全部替换)
print(a.replace('I','gg'，1) 
gg love you I

(12)isdigit 判断是否为整数
print('88'.isdigit()) #true
print('hh'.isalpha()) 是否是字符串
#true

• 总结

只能存一个值，有序，不可变类型
name='qqc'
b=name.replace('q','w')
print(id(name)) #5145600
print(id(b)) #5145664
#id已变为不可变类型

3.列表 list

• 定义：在[]内可以有多个任意类型的值，逗号分隔
• 相关操作
  索引，切片，成员运算，长度与字符串用法相同
• 追加

#末尾添加 append
names=['qqc','wx','ggx','fln']
print(names.append('gg') 

#指定位置添加 insert
names=['qqc','wx','ggx','fln']
names.insert(1,'gg')
print(names)
#['qqc', 'gg', 'wx', 'ggx', 'fln']

添加多个值 extend
names.extend([7,2,3])

• 删除

# del 指定索引删除  
names=['qqc','wx','ggx','fln']
del names[2]
print(names)
# ['qqc', 'wx', 'fln']

# remove  删除指定的元素,没有返回值  
names=['qqc','wx','ggx','fln']
names.remove('wx')
print(names)

# pop() 指定索引删除，有返回值
names=['qqc','wx','ggx','fln']
res=names.pop(2)
print(res)   #ggx
print(names) # ['qqc', 'wx', 'fln']

• 通过值取索引 index

names=['qqc','wx','ggx','fln']
print(names.index('qqc')) # 0

• 排序
  字符串比较(小写>大写，a至z变小,从第一位开始依次比较后面的值)

sort 从小到大排序
name=[1,10,-3,11]
name.sort()                 
print(name)

#当倒序reverse =true时，从大到小排序，
name=[1,10,-3,11]
name.sort(reverse =True)                 
print(name)
#[11, 10, 1, -3]

• 类型总结

(1)可以储存多个值，值可以是任意类型
(2)有序
(3)可变类型(修改值以后ID依然相等)
l=['a','b']
print(id(l)) #4845856
l[0]='A'
print(id(l)) #4845856

4. 元组 tuple

• 定义：在()内用逗号分割开，可以存放任意类型的值
• 用途：元组是不可变的列表，能存多个值，但多个值只有取的需求，而没有改的需求，那么用元组合最合理；(当元组内只有有个元素时，要加逗号)
• 相关操作

1、按索引取值(正向取+反向取)：只能取   
2、切片(顾头不顾尾，步长)
3、长度
4、成员运算in和not in
5、循环
注：用法同列表

• 内置方法

names=('lggx','effn','wx','lxx','chxx','lxx')
print(names.count('lxx')) #个数
print(names.index('wx')) #元素索引

• 总结：

可以存多个值
有序
不可变类型
(值改变，ID变为不可变类型，ID不变为可变类型)
与列表区别：（1）元组缓存于Python运行时环境，每次使用元组时无须访问内核去分配内存；创建开销小；适用存放一个不会改变事物的多个属性

5. 字典 dic

• 定义：{}内用逗号分隔开多个元素，每一个元素都是key：value的形式
  value可以是任意数据类型，但是key必须为不可变类型，key通常应该是字符串类型
• 用途：用来存多个值，但每一个值都有一个key与之对应，key对值有描述性的功能
  当存储多个值表示的不同的状态
• 相关操作

1、按key存取值：增,取,改
d={'x':1,'y':2}
d['z']=3
print(d)  #增
print(d['x']) #取
d['x']=100 #改
print(d)

2、长度len
print(len(d))

3、成员运算in和not in
(判断字典中的key)

4、删除
(1)指定key值删除 del
d ={'x':1,'y':2,'z':100}
del d['x']
print(d)  #{'y': 2, 'z': 100}
(2)拿走一个值，有返回值 pop
d ={'x':1,'y':2,'z':100}
res=d.pop('y')
print(d)
print(res) # 2 (被删除的key,对应的value)
(3) 删除最后一个键值对 popitem
d ={'x':1,'y':2,'z':100}
res=d.popitem()
print(d)  #{'x': 1, 'y': 2}
print(res) #('z', 100) 
#被删除的键值对以元组的形式返回

5、键keys()，值values()，键值对items()
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
}
print(msg_dic.key())
结果：dict_keys(['apple', 'tesla', 'mac'])
print(msg_dic.values())
结果：dict_values([10, 100000, 3000])
print(msg_dic.items())
结果：dict_items([('apple', 10), ('tesla', 100000), ('mac', 3000)])
#转成列表
print(list(msg_dic.keys()))
结果：['apple', 'tesla', 'mac']

6、循环
(1) 只取key
d={'a':1,'b':2,'c':3,'d':4}
for k in d:
    print(k)   #abcd
#for k in msg_dic.keys():
#     print(k,msg_dic[k])
(2)只取value
d={'a':1,'b':2,'c':3,'d':4}
for v in d .values() :
    print(v)
(3)取key和value
d={'a':1,'b':2,'c':3,'d':4}
for d,v in d.items():
    print(k,v)

• 内置方法

(1) get(key,默认值) 取值，如果字典没有指定的key也不会报错，返回默认值None,也可自己设置默认值
d={'x':1,'y':2,'z':3}
v=d.get('g','hello')
print(v)
结果：hello
#字典的key值中没有‘g’，返回默认值hello

(2)update 更新字典元素
d={'x':1,'y':2,'z':3}
d1={'a':1,'x':1111}
d.update(d1)
print(d)
结果：{'x': 1111, 'y': 2, 'z': 3, 'a': 1}

(3)fromkeys() 创建新字典
l=['name','age','sex']
d={}
for k in l:
    d[k]=None 
d=dict.fromkeys(l,None)
print(d)
结果：{'name': None, 'age': None, 'sex': None}
#key值不一样，value一样

(4)setdefault() 
#键不存在于字典中，将会添加键并将值设为默认值
info={'name':'egon','age':18,'sex':'male'}
res=info.setdefault('height',1.80)
print(res)  #1.80
print(info)
结果：{'name': 'egon', 'age': 18, 'sex': 'male', 'height': 1.8}
#如果字典中包含有给定键，则返回该键对应的值，否则返回为该键设置的值
info={'name':'egon','age':18,'sex':'male'}
res=info.setdefault('name','EGON_NB')
print(res)  #egon
print(info)
结果：{'name': 'egon', 'age': 18, 'sex': 'male'}

• 总结：

无序、可变类型

6. 集合 set

• 定义：用{}可以包含多个元素，用逗号隔开，集合内元素是不可变类型，没有重复元素，无序的
• 作用：将不同的值存在一起，不同的集合用来做关系运算
• 集合去重注意事项：

(1)去重的目标所包含的值为不可变类型;
(2)去重后原有值的顺序被打乱
l=['a','b',1,'a','a']
a = set(l)
print(a)

• 基本操作

(1)运算操作
name = {'dd','gg','dd','ggg','ffb'}
name1 = {'dd','dxd','ggg','cc'}
print(name|name1)  #合集 {'cc', 'dd', 'gg', 'ffb', 'dxd', 'ggg'}
print(name&name1)  #交集 {'dd', 'ggg'}
print(name-name1)  #差集 {'gg', 'ffb'}
print(name^name1)  #对称差集 {'cc', 'gg', 'ffb', 'dxd'}
(2)父集包含关系(>,>=)，子集被包含关系(<,<=)
s1={1,2,3,4,5}
s2={1,2,3}
print(s1 > s2) # s1包含s2 True
print(s1.issuperset(s2)) #True (包含）
print(s2.issubset(s1))  #True （子集）

• 内置方法

name = {'dd','gg','dd','gbg','ffb'}
#成员运算 in， not in
print(len(name)) #元素个数
name.add('vv')  #添加新元素
print(name)
name.update([1,3,4])  #添加多个元素
print(name)
name.remove('dd')  #删除指定的元素,没有指定的元素报错
print(name)
name.discard('c') #如果存在指定的元素就删除
print(name)
c=name.copy()  #复制集合
print(c)
print(name.pop())  #返回集合中的一个不确定元素
name.clear() #删除集合元素
print(name) #set()

• 总结

无序、
存多个值
值唯一
可变类型

7. 布尔类型 bool

• 作用：
  判断一个条件成立时，用True标识，不成立则用False标识
• 注意：

1、None，0，空（空字符串，空列表，空字典等）三种情况下布尔值为False
2、其余均为真 

---

占位符：
food='chicken'
print('今天 %s' %(food))
print('今天 {}'.format(food))
print(f'今天{food}')