基础数据类型的整理

基础数据类型

一、数字int

数字主要是用于计算用的，使用方法并不是很多，就记住一种就可以：

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

二、字符str

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

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

a = 'ABCDEFGHIJK'
print(a[0:3])
print(a[2:5])
print(a[0:]) #默认到最后
print(a[0:-1]) #-1就是最后一个
print(a[0:5:2]) #加步长
print(a[5:0:-2]) #反向加步长

3.字符串的常用方法

#captalize,swapcase,title
print(name.capitalize()) #首字母大写
print(name.swapcase()) #大小写翻转
msg='egon say hi'
print(msg.title()) #每个单词的首字母大写

# 内同居中，总长度，空白处填充
ret2 = a1.center(20,"*")  
print(ret2)

#数字符串中的元素出现的个数。
# ret3 = a1.count("a",0,4) # 可切片
# print(ret3)

a2 = "hqw	"
#	前面的补全
# 默认将一个tab键变成8个空格，如果tab前面的字符长度不足8个，则补全8个，如果tab键前面的字符长度超过8个不足16个则补全16个，以此类推每次补全8个。
ret4 = a2.expandtabs()
print(ret4)

a4 = "dkfjdkfasf54"
#startswith 判断是否以...开头
#endswith 判断是否以...结尾
# ret4 = a4.endswith('jdk',3,6)  # 顾头不顾腚
# print(ret4)  # 返回的是布尔值
# ret5 = a4.startswith("kfj",1,4)
# print(ret5)

#寻找字符串中的元素是否存在
# ret6 = a4.find("fjdk",1,6)
# print(ret6)  # 返回的找到的元素的索引，如果找不到返回-1

# ret61 = a4.index("fjdk",4,6)
# print(ret61) # 返回的找到的元素的索引，找不到报错。

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

#format的三种玩法 格式化输出
res='{} {} {}'.format('egon',18,'male')
res='{1} {0} {1}'.format('egon',18,'male')
res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)

#strip
name='*egon**'
print(name.strip('*')) 
print(name.lstrip('*'))
print(name.rstrip('*'))

#replace
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1))

#####is系列
name='jinxin123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成
print(name.isdigit()) #字符串只由数字组成

#公共方法
公共方法：
s = 'aasfhfsaflf'
len()  #总个数
print(len(s))
count  #计算某些元素出现的个数,可切片
c1 = s.count('f')
print(c1)

三、bool值

布尔值就两种：True，False。就是反应条件的正确与否。

真   1   True。

假   0   False。 

四、列表list

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

li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]

列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。

1.增

li = [1,'a','b',2,3,'a']
li.insert(0,55) #按照索引去增加
print(li)
li.append('aaa') #增加到最后
li.append([1,2,3]) #增加到最后
print(li)

li.extend(['q,a,w']) #迭代的去增
li.extend(['q,a,w','aaa'])
li.extend('a')
li.extend('abc')
li.extend('a,b,c')
print(li)

2.删

l1 = ['wusir', True, 'alex', 'laonanhai', 'ritian', 'taibai']
#pop 按照索引去删除, 有返回值
ret = l1.pop(0)
print(ret)
print(l1)

#remove 按照元素删除
l1.remove('alex')
print(l1)

#clear 清空列表
l1.clear()
print(l1)

# del
#1，在内存级别删除列表
del l1
print(l1)
#2，按照索引删除。
del l1[2]
print(l1)
#3，切片删除+步长。
del l1[:-1]
print(l1)

3. 改

#1，按照索引去改。
l1[0] = '肖锋'
print(l1)
l1[-1] = '男神'
print(l1)
#2，按照切片去改,先将切片的区域内的内容全部删除，在迭代着添加内容。
l1[:3] = '范德萨发给ghfkhgh;'
l1[:3] = [1111, 2222, 3333, 4444]
print(l1)

4.查

# 按照索引切片去查
#for循环
# for i in l1:
#     print(i)

5.公共方法

len 个数
cou = len(l1)
print(cou)

count 元素个数
print(l1.count('taibai'))

index 通过元素找索引
print(l1.index('alex', 3))

l2 = [1, 3, 5, 9, 7, 6, 2, 4]
sort 从小到大，正序排序
l2.sort()
print(l2)
sort 从大到小，倒序排序
l2.sort(reverse=True)
print(l2)

翻转 reverse
l2.reverse()
print(l2)

列表的嵌套

l1 = ['wusir', 'alex', [99, ' taibai', '98'], 21]
# 1, 将wusir变成全部的大写。
# l1[0] = 'WUSIR'
# print(l1)
# print(l1[0].upper())
# l1[0] = l1[0].upper()
# print(l1)

# 2，将‘taibai'变成首字母大写，其他字母小写，放回原处。
# print(l1[2])
# l2 = l1[2]
# l2[1] = l2[1].strip().capitalize()
# l1[2][1] = l1[2][1].strip().capitalize()
# print(l1)
# l1[2].append('舒淇')
# print(l1)
# 3，用数字的相加将99 变成 字符串的 '100'.
# l1[2][0] = str(l1[2][0] + 1)
# print(l1)
# 4，字符串的'98' 变成数字的100.
# l1[2][2] = int(l1[2][2]) + 2
# print(l1)

在循环一个列表时，最好不要改变列表的大小，会影响你的最终结果。

l1 = [111, 222, 333, 444, 555, ]
del l1[1::2]
print(l1)

# 倒着删除。
for index in range(len(l1)-1, -1, -1):
    if index % 2 == 1:
         del l1[index]
print(l1)

五、字典dict

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

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

1.增

dic = {'name': '老男孩', 'age': 56, 'hobby': 'women'}
dic['sex'] = 'LaddyBoy'
dic['name'] = 'Alex'  有则覆盖，没有就添加
dic.setdefault('sex')
dic.setdefault('sex', 'Laddyboy') 有则不变，无则添加。
dic.setdefault('name', 'alex')
print(dic)

2.删

print(dic.pop('age'))  # 有返回值，返回的是键对应的值
print(dic.pop('age1', '没有此键...'))
print(dic)

dic.clear() 清空字典
print(dic)

print(dic.popitem())  # 随机删除，有返回值，返回值为元组，里面是删除的键值对。
print(dic)

del
1，删除整个字典
del dic
2，按照键删除键值对
del dic['name']
print(dic)

3.改

1, dic['name'] = 'Alex'  有则覆盖，没有就添加
update 两个字典的更新
dic = {"name": "jin", "age": 18, "sex": "male"}
dic2 = {"name": "alex", "weight": 75}
dic2.update(dic)  # 将dic里面的所有键值对 覆盖添加到dic2中，dic不变
print(dic)  # {'name': 'jin', 'age': 18, 'sex': 'male'}
print(dic2)  # {'name': 'jin', 'weight': 75, 'age': 18, 'sex': 'male'}

4.查

1,dic['name']
print(dic['name1'])

2,dic.get('name')
print(dic.get('name'))
print(dic.get('name1'))
print(dic.get('name1', 'sb没有此键'))

#for循环查询
dic.keys(), dic.values(), dic.items()  #类似于list但不是list的类型。
print(dic.keys(),type(dic.keys()))
for key in dic.keys():
    print(key)
l_key = list(dic.keys())
print(l_key)

for value in dic.values():
    print(value)

l_value = list(dic.values())
print(l_value)
print(dic.items())

字典的嵌套

# dic = {
#     'name_list': ['碗蓉', '俊俊', '爽妹'],
#     'status': None,
#     'personal_msg': {
#         'name': '反面教材',
#         'age': 25,
#         'hobby_list': ['抽烟', '喝酒', '烫头'],
#     }
# }

# 1,给dic添加一个键值对，学校：老男孩
# dic['学校'] = '老男孩'
# print(dic)
# 2，将status对应的值改成True
# dic['status'] = True
# print(dic)
# 3，给name_list对应的列表追加一个元素：平平
# print(dic['name_list'])
# dic['name_list'].append('平平')
# print(dic)
# 4，给personal_msg对应的字典添加一个键值对sex：男
# dic2 = dic['personal_msg']
# dic2['sex'] = '男'
# print(dic)
# dic['personal_msg']['sex'] = '男'
# print(dic)
# 5，将hobby_list 对应的列表中的烫头改成唱歌。
dic['personal_msg']['hobby_list'][-1] = '唱歌'
print(dic)

在循环dict中，最好不要改变dict的大小，会影响结果或者报错。

dic = {'k1': 'v1', 'k2': 'v2','k3': 'v3','name': 'alex'}
for i in dic:
    if 'k' in i:
        del dic[i]
print(dic)


l1 = []
for key in dic:
    if 'k' in key:
        l1.append(key)
# print(l1)
for key in l1:
    del dic[key]
print(dic)

dic = dict.fromkeys('abc', 666)
print(dic)
dic = dict.fromkeys([11, 22, 33], 666)
print(dic)
dic = dict.fromkeys([1, 2, 3], [])
dic[1].append(666)
print(dic)

C:PythonPython36python3.exe "D:/老男孩12期笔记/day07/day07课堂笔记/day07/02 数据类型的补充.py"
{'a': 666, 'b': 666, 'c': 666}
{11: 666, 22: 666, 33: 666}
{1: [666], 2: [666], 3: [666]}

Process finished with exit code 0

六、元组tuple

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

# tu = (11, 22, 33, 44, 55)
#索引，切片，步长
# print(tu[0])
# print(tu[:3:2])
# for i in tu:
#     print(i)
# index  len  count
tu1 = ('wusir', 'alex', [22, 44, 'taibai'],)
# tu1[-1].append('女神')
# print(tu1)
# l1 = [22,33]
# l1.append(tu1)
# # print(l1)
# l1.clear()
# print(l1)
# del tu1
# print(tu1)
# l2 = [1,('wusir', 'alex', [22, 44, 'taibai'],)]
# l2.clear()
# print(l2)

元组里面如果只有一个元素且没有逗号，则该数据的数据类型与里面的元素相同。

tu1 = ('laonanhai')
tu2 = ('laonanhai',)
print(tu1, type(tu1))
print(tu2, type(tu2))

tu1 = (1)
tu2 = (1,)
print(tu1, type(tu1))
print(tu2, type(tu2))

tu1 = ([1, 2, 3])
tu2 = ([1, 2, 3],)
print(tu1, type(tu1))
print(tu2, type(tu2))

七、集合set

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

　　去重，把一个列表变成集合，就自动去重了。

　　关系测试，测试两组数据之前的交集、差集、并集等关系。

1，集合的创建。

set1 = set({1,2,'barry'})
set2 = {1,2,'barry'}
print(set1,set2)  # {1, 2, 'barry'} {1, 2, 'barry'}

#空集合表示方法为 
set()

2.集合的增

# add
set1 = {'alex','wusir','ritian','egon','barry'}
set1.add('景女神')
print(set1)

#update：迭代着增加
set1.update('A')
print(set1)
set1.update('老师')
print(set1)
set1.update([1,2,3])
print(set1)

3.集合的删

set1 = {'alex','wusir','ritian','egon','barry'}

set1.remove('alex')  # 删除一个元素
print(set1)

set1.pop()  # 随机删除一个元素
print(set1)

set1.clear()  # 清空集合
print(set1)

del set1  # 删除集合
print(set1)

4.集合的查

#for循环
for i in set1:
     print(i)

5.集合的交集并集等操作

1.交集（&  或者 intersection）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2)  # {4, 5}
print(set1.intersection(set2))  # {4, 5}

2.并集（| 或者 union）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2)  # {1, 2, 3, 4, 5, 6, 7}

print(set2.union(set1))  # {1, 2, 3, 4, 5, 6, 7}

3.差集（- 或者 difference）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2)  # {1, 2, 3}
print(set1.difference(set2))  # {1, 2, 3}

4.反交集 （^ 或者 symmetric_difference）

set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2)  # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2))  # {1, 2, 3, 6, 7, 8}

5.子集与超集

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}

print(set1 < set2)
print(set1.issubset(set2))  # 这两个相同，都是说明set1是set2子集。

print(set2 > set1)
print(set2.issuperset(set1))  # 这两个相同，都是说明set2是set1超集。

八、其他（for，enumerate，range）。

1.for循环：用户按照顺序循环可迭代对象的内容。

msg = '老男孩python是全国范围内最好的python培训机构'
for item in msg:
    print(item)

li = ['alex','银角','女神','egon','太白']
for i in li:
    print(i)

dic = {'name':'太白','age':18,'sex':'man'}
for k,v in dic.items():
    print(k,v)

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

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

li = ['alex','银角','女神','egon','太白']
for i in enumerate(li):
    print(i)
for index,name in enumerate(li,1):
    print(index,name)
for index, name in enumerate(li, 100):  # 起始位置默认是0，可更改
    print(index, name)

3.range：指定范围，生成指定数字。

range 当做自定义的数字范围列表,
满足顾头不顾腚,可以加步长，与for循环结合使用。

for i in range(0, 101):  #[0,1,2,3,....100]
    print(i)
for i in range(11):  # [0,1,2,3,....10]
    print(i)
for i in range(0, 101, 3):
    print(i)
for i in range(10, 0, -1):
    print(i)
l1 = [22, 33, 33, 33, 66, 77, 88, 99]
for i in l1:
    print(l1.index(i))
for i in range(len(l1)):
    print(i)
l1 = ['wusir', 'alex', [99, ' taibai', '98'], 21]
for i in l1:
    if type(i) == list:
        for j in i:
            print(j)
    else:print(i)