Python-基础-day3

基础数据类型

1、什么是数据类型？

　　我们人类可以很容易的分清数字与字符的区别，但是计算机并不能呀，计算机虽然很强大，但从某种角度上看又很傻，除非你明确的告诉它，1是数字，“汉”是文字，否则它是分不清1和‘汉’的区别的，因此，在每个编程语言里都会有一个叫数据类型的东东，其实就是对常用的各种数据类型进行了明确的划分，你想让计算机进行数值运算，你就传数字给它，你想让他处理文字，就传字符串类型给他。Python中常用的数据类型有多种，如下：

　整数(int) 、字符串(str)、布尔值(bool)、列表(list)、元组(tuple)、字典(dict)、集合(set)

2、基础数据类型

2.1、数字（int）

数字使用来计算的，使用场景不多，我们知道有这个数据类型，会使用一种即可：

#数字int
#bit_length() 当十进制用二进制表示时，最少使用的位数
aihuidi = 11
data = aihuidi.bit_length()
print(data)

2.2、布尔值（bool）

布尔值就两种：True、False。含有条件就时正确与不正确（否）

真  1  True

假  0  False

2.3、

字符串（str）

字符串的索引与切片

索引即下标，就时字符串组成的元素从第一个开始，初始索引为0以此往后推。

#索引：
aihuidi = 'ABCDEFGHIJKLMNOPQRSTUVWSXYZ'
print(aihuidi[0])
print(aihuidi[3])
print(aihuidi[8])
print(aihuidi[23])

切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾腚）。

#切片：
aihuidi = 'ABCDEFGHIJKLMNOPQRSTUVWSXYZ'
print(aihuidi[0:8])
print(aihuidi[3:16])
print(aihuidi[0:])     #默认打印到最后一个
print(aihuidi[0:-1])   #-1 是列表中的最后一个元素，但是要满足顾头不顾腚的原则，所以取不到Z元素
print(aihuidi[0:5:2])   #加步长
print(aihuidi[5:0:-2])   #反向加步长

字符串的常用方法。

name = "aihuidi"
print(name.capitalize())  #首字母大写
print(name.swapcase())   #大小写反转
hhh = 'dong liu weu mng'
print(hhh.title())     #每个单词的首字母大写
#内同居中，总长度为20，空白处以*填充
a1 = '1a3a45haj'
ret2 = a1.center(20,"*")
print(ret2)
#a在字符串中的元素出现的个数
ret3 = a1.count("a",0,8)   #可切片
print(ret3)
a4 = "aihuidi is my hhh"
ret4 = a4.startswith('aihuidi')    #.startswith判断是否以'aihuidi'开头，是的话返回True,不是返回False
ret4 = a4.startswith('my',11,13)
print(ret4)
ret4 = a4.endswith('h')    #.endswithh判断是以'h'结尾，是的话返回True，不是返回False
print(ret4)
#寻找字符串中的元素是否存在
ret5 = a4.find("is",8,10)
print(ret5)  #如果存在返回找到的元素的索引，找不到返回-1

ret6 = a4.index("is",8,10)    #如果存在返回找到的元素的索引，找不到报错
print(ret6)

#.split 以什么分割，最终形成一个列表，然而此列表不含有这个分割的元素
ret7 = 'title,Tilte,atre,'.split('t')
print(ret7)

#format的三种使用，格式化输出
res='{} {} {}'.format('aihuidi',19,'hhh')
res1='{2} {0} {1}'.format('aihuidi',19,'hhh')
res2='{name} {age} {your}'.format(your='hhh',age='',name='aihuidi')
print(res)
print(res1)
print(res2)

#strip用于移除字符串头尾指定的字符，注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。
name = '*aihuidi**'
print(name.strip('*'))   #去除首尾的*
print(name.lstrip('*'))
print(name.rstrip('*'))

#replace字符串中的 old（旧字符串） 替换成 new(新字符串)
name = 'aihuidi hhhh is shi ge ddddd aihuidi'
print(name.replace('aihuidi','你是',1))  #把'aihuidi'替换成'你是'
#is系列
name = 'aihuidi678'
print(name.isalnum())   #字符串由字母或数字组成的
print(name.isalpha())   #字符串只由字母组成
print(name.isdigit())   #字符串只由数字组成

2.3、元组（tuple）

元组被称为只读列表，即数据可以被查询，但不能被修改，所以，字符串的切片操作同样适用于元组。例：（1，2，3）（"a","b","c"）

2.4、列表（list）

列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以 [] 括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如：

list = ['aihudi',233,(5,6,'hhh'),[7,8,'dddd'],{'nnnn'}]
列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素,
而且列表是有序的，有索引值，可切片，方便取值。

#增
list = ['aihuidi',1,6,8,'hhhh',9]
list.insert(0,55)       #按照索引去增加
list.insert(2,66)
list.append('mmm')      #增加到最后
list.extend(['q,f,b'])  #迭代的去增
list.extend('jjjj')
print(list)
#删
li = ['hhhh','nnnn',1,6,8,'add']
ll = li.pop(1)    #按照位置进行删除，有返回值，"返回的就是你所删除的那个"
print(ll)
del li[1:4]  #可以按位置删除，也可以切片删除没有返回值
print(li)
li.remove('add')  #按照元素进行删除，没有返回值
print(li)
li.clear()  #清空列表
#改
lll = [2,4,6,8,10,'aihuidi','a']
lll[0] = 12
lll[5] = 'hhhhh'
lll[2:4] = ['b','n']
print(lll)
#查
切片去查，或者循环去查。

其他一些操作用法

#count用法：计算或 统计某个元素出现的次数
aaa = ["a","b","a","k","e"]
print(aaa.count("a"))
#index用法:从列表中找出某个值第一个匹配项的索引位置
print(aaa.index("k"))
#sort用法：用于在原位置对列表进行排序
bbb = [3,5,1,4,2]
bbb.sort()
print(bbb)
#reverse用法：将列表中的元素反向存放
bbb.reverse()
print(bbb)

2.5、字典（dict）

字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。

　　字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典的语法：

#key-value
info = {
    'stu1': "aihuidi",
    'stu2': "hhhh",
    'stu3': "dddd",
}
print(info)
print(info["stu1"])

基础使用：

info = {
    'stu1': "aihuidi",
    'stu2': "hhhh",
    'stu3': "dddd",
}
# print(info)
# print(info["stu1"])
#增加
info["stu4"] = "laili"
print(info)
#修改
info["stu1"] = "爱辉弟"
print(info)
#删除
info.pop("stu1")
print(info)    #标准化删除方式
del info["stu2"]
print(info)    #另一种删除方式
info.popitem()  #随机删除
print(info)
#查
info1 = {'stu01': 'aihuidi', 'stu02': 'zhidao','stu03': 'hoade'}
value = info1['stu02']     #有就返回值，没有就报错
value1 = info1.get('stu06',"没有")  #有就返回对应的值，没有就返回设定的值''没有''
print(value)
print(value1)

字典的循环

#字典的循环
dic = {"name": "aihuidi","age":19,"nono":"aiai"}
for key in dic:
    print(key)
for item in dic.items():
    print(item)
for key,value in dic.items():
    print(key,value)

其他操作

item = dic.items()
print(item,type(item))  # dict_items([('name', 'jin'), ('sex', 'male'), ('age', 18)]) <class 'dict_items'>
# 这个类型就是dict_items类型，可迭代的

keys = dic.keys()
print(keys,type(keys))  # dict_keys(['sex', 'age', 'name']) <class 'dict_keys'>

values = dic.values()
print(values,type(values))  # dict_values(['male', 18, 'jin']) <class 'dict_values'>     #同上

输出结果如下：

2.6、集合（set）

集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。

以下是集合最重要的两点：

• 去重，把一个列表变成集合，就自动去重了
• 关系测试，测试两组数据之前的交集、差集、并集等关系

#set 集合
set1 = set({1,2,'barry'})
set2 = set({1,2,'barry'})
print(set1,set2)
#结果：{1, 2, 'barry'} {1, 2, 'barry'}
#增
set1 = {'aihuidi','hhhh','work','ordinary'}
print(set1)
#结果：{'work', 'aihuidi', 'hhhh', 'ordinary'}
set1.add('self-discipline')
print(set1)
#结果：{'work', 'aihuidi', 'hhhh', 'ordinary', 'self-discipline'}
#update：迭代的增加
set1.update('strong')
print(set1)
#结果：{'aihuidi', 'g', 'r', 'o', 'n', 't', 'work', 's', 'hhhh', 'ordinary', 'self-discipline'}
set1.update('nonoea')
print(set1)
#结果：{'aihuidi', 'g', 'a', 'r', 'o', 'n', 't', 'work', 'e', 's', 'hhhh', 'ordinary', 'self-discipline'}
#集合的删
set1 = {'aihuidi','hhhh','work','ordinary'}
set1.remove('work')
print(set1)
#结果：{'ordinary', 'hhhh', 'aihuidi'}
set1.pop()   #随机删除
print(set1)
#结果： #因是随机的所以产生的结果不一样

集合的其他操作

交集

#交集（&或者intersection）
set1 = {1,3,5,7,9}
set2 = {1,4,3,8,10}
print(set1 & set2)   #两个集合里都有1和3{1，3}
#结果：{1, 3}

并集

#并集（\ 或者 union）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2)
#结果：{1, 2, 3, 4, 5, 6, 7, 8}
print(set2.union(set1))
#结果：{1, 2, 3, 4, 5, 6, 7, 8}

差集

#差集（- 或者 difference）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2)
#结果：{1, 2, 3}
print(set2 - set1)
#结果：{8, 6, 7}
print(set1.difference(set2))
#结果：{1, 2, 3}
print(set2.difference(set1))
#结果：{8, 6, 7}

反交集

#反交集 （^ 或者 symmetric_difference）
set1 = {1,2,3,4,5,10}
set2 = {4,5,6,7,8}
print(set1 ^ set2)   #两个集合里都有{4，5}
#结果：{1, 2, 3, 6, 7, 8, 10}
print(set1.symmetric_difference(set2))
#结果：{1, 2, 3, 6, 7, 8, 10}

子集与超集

#子集和超集
set1 = {1,2,3}
set2 = {1,2,3,4,5,6}
print(set1 < set2)
#结果：True
print(set1.issubset(set2))  #这两个相同，都是说明set1是set2子集
#结果：True
print(set2 > set1)
#结果：True
print(set2.issubset(set1))  #这两个相同，都是说明set2是set1超集
#结果：False

frozenset不可变集合，让集合变化不可类型

#frozenset不可变集合，让集合变化不可类型
s = frozenset('abcde')
print(s,type(s))
#结果：frozenset({'d', 'a', 'e', 'b', 'c'}) <class 'frozenset'>

基础数据类型的总结

按存储空间的占用分（从低到高）

数字
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

按存值个数区分

标量/原子类型	数字，字符串
容器类型	列表，元组，字典

按可变不可变区分

可变	列表，字典
不可变	数字，字符串，元组，布尔值

按访问顺序区分

直接访问	数字
顺序访问（序列类型）	字符串，列表，元组
key值访问（映射类型）	字典

2.7、其他（for、enumearte、range）

for循环：用户按照顺序循环可迭代对象的内容msg = '爱辉弟要加油学习python哦'

msg = '爱辉弟要加油学习python哦'

for item in  msg:
    print(item)
#结果：

爱
辉
弟
要
加
油
学
习
p
y
t
h
o
n
哦

li = ['aihuidi','hhhh','sache','delte']
for i in li:
    print(i)
#结果：
# aihuidi
# hhhh
# sache
# delte

dic = {'name':'aihuidi','age':19,'sex':'man'}
for k,v in dic.items():
    print(k,v)
#结果：
# sex man
# name aihuidi
# age 19

enumerae：枚举，对于一个可迭代的（iterable）/可遍历的对象（如：列表、字符串），

enumerate将其组成一个索引序列，利用它可以同时获得索引和值。

kk = ['aihuidi','无敌','厂子','专业']
for i in enumerate(kk):
    print(i)
#结果：
# (0, 'aihuidi')
# (1, '无敌')
# (2, '厂子')
# (3, '专业')
for index,name in enumerate(kk,1):
    print(index,name)
#结果:
# 1 aihuidi
# 2 无敌
# 3 厂子
# 4 专业

for index, name in enumerate(kk, 100):   #起始位置默认是0，也可根据场景进行更改
    print(index, name)
#结果:
# 100 aihuidi
# 101 无敌
# 102 厂子
# 103 专业

range：指定范围内，生成指定数字

for i in range(1,10):
    print(i)
#结果:
#
#
#
#
#
#
#
#
#

for i in range(1,10,2):    #步长
    print(i)
#结果：
#
#
#
#
#
for i in range(10,1,-2):    #反向步长
    print(i)
#结果：
#
#
#
#