一，引子。

1 什么是数据？

　　x=10，10是我们要存储的数据

2 为何数据要分不同的类型

　　数据是用来表示状态的，不同的状态就应该用不同的类型的数据去表示

3 数据类型

　　数字

　　字符串

　　列表

　　元组

　　字典

　　集合

二基础数据类型。

数字int。

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

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

 

布尔值bool。

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

真   1   True。

假   0   False。    

字符串str。

字符串的索引与切片。

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

a = 'ABCDEFGHIJK'
print(a[0])
print(a[3])
print(a[5])
print(a[7])

 

 

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

a = 'ABCDEFGHIJK'
print(a[0:3])
print(a[2:5])
print(a[0:]) #默认到最后
print(a[0:-1]) # -1 是列表中最后一个元素的索引，但是要满足顾头不顾腚的原则，所以取不到K元素
print(a[0:5:2]) #加步长
print(a[5:0:-2]) #反向加步长

 

 

字符串常用方法。

#字符串的索引与切片
'''
s = 'ABCDLSESRF'
#索引
# s1 = s[0]
# print(s1)
# s2 = s[2]
# print(s2)
# s3 = s[-1]
# print(s3)
# s4 = s[-2]
# print(s4)
# #ABCD   切片 ：顾头不顾尾
# s5 = s[0:4]
# print(s5)
# s6 = s[0:-1]
# print(s6)
# s7 = s[:]
# s8 = s[0:]
# print(s7,s8)
# s9 = s[0:0]
s = 'ABCDLSESRF'  # s[首:尾:步长]
# s10 = s[0:5:2]
# print(s10)
s11 = s[4:0:-1]
print(s11)
s12 = s[3::-1]
print(s12)
s13 = s[3::-2]
print(s13)
s = 'ABCDLSESRF'
s14 = s[-1::-1]
print(s14)
s15 = s[::-1]
print(s15)
'''

#字符串的操作
s = 'alexWUsir'
s1 = s.capitalize()  # 首字母大写
# print(s1)

# 全大写，全小写
s2 = s.upper()
s21 = s.lower()
# print(s2,s21)
'''
s_str= 'acEQ1'
you_input =input('请输入验证码，不区分大小写')
if s_str.upper() == you_input.upper():
    print('输入成功')
else:
    print('请重新输入')
'''
#大小写翻转
# s3 = s.swapcase()
# print(s3)
# 每个隔开(特殊字符或者数字)的单词首字母大写
# s = 'alex*egon-wusir'
# s4 = s.title()
# print(s4)
# s = 'fade,crazy*w4rri0r_songsong node_3'
# s4 = s.title()
# print(s4)

#居中，空白填充
# s = 'alexWUsir'
# s5 = s.center(20,'~')
# print(s5)

# s = 'alex\tsir'
# s6 = s.expandtabs()
# print(s6)

# s = 'alex二哥'
# #公共方法
# l = len(s)
# print(l)

#以什么开头结尾 endswith
# s = 'alexWUsir'
# s7 =s.startswith('alex')
# s71 = s.startswith('e',2,5)
# print(s71)
'''
if s7:
    pass
elif s.startswith('bl'):
    pass
print(s7)
'''
# find 通过元素找索引，找不到返回-1
#
# index通过元素找索引，找不到报错
# s = 'alexWUsir'
# s8 = s.find('A')
# s81 = s.index('A')
# print(s81,type(s8))

#strip rstrip lstrip
# s = 'alexWUsir%'
# s9 = s.strip('%')
# print(s9)
# s = ' *a%lexWUsi* r%'
# s91 = s.strip(' %*')
# print(s91)

# strip 默认删除前后空格

# username = input('请输入名字：').strip()
# if username =='春哥':
#     print('恭喜春哥发财')

# s = 'alexaa wusirl'
# s10 = s.count('al')
# print(s10)

# split   str ---->list
# s = ';alex;wusir;taibai'
# l = s.split('a')
# print(l)

#format的三种玩法 格式化输出
# s = '我叫{}，今年{}，爱好{}，再说一下我叫{}'.format('太白',36,'girl','太白')
# print(s)
# name = input('请输入名字：')
# s = '我叫{0}，今年{1}，爱好{2}，再说一下我叫{0}'.format(name,36,'girl')
# print(s)
# name = input('请输入名字：')
# s = '我叫{name}，今年{age}，爱好{hobby}，再说一下我叫{name}'.format(age=18,name=name,hobby='girl')
# print(s)

# s = '来看待街坊邻居复合大师街坊法好的撒见客户'
# s11 = s.replace('街坊','老王',1)
# print(s11)

# s = 'fhdsklfds'
# for i in s:
#     print(i)
s = 'fdsa苍井空fdsalk'
if '苍井空' in s:
    print('您的评论有敏感词...')

 

元祖tuple。

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

# 元祖 只读列表，可循环查询，可切片。
# 儿子不能改，孙子可能可以改。
tu = (1, 2, 3, 'alex', [2, 3, 4, 'taibai'], 'egon')
print(tu[3])
print(tu[0:4])
for i in tu:
    print(i)
tu[4][3] = tu[4][3].upper()
print(tu)

# 修改元组中孙子值
tu[4].append('sb')
print(tu)

s = 'alex'
s1 = 'sb'.join(s)
print(s1)

# 列表转化成字符串  list -----> str    join
li = ['taibai', 'alex', 'wusir', 'egon', '女神', ]
s = '++++'.join(li)
# str ----->list  split()
print(s)

 

列表list

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

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

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

 

列表增删改查操作

li = ['alex', [1, 2, 3], 'wusir', 'egon', '女神', 'taibai']
l1 = li[0]
print(l1)
l2 = li[1]
print(l2)
l3 = li[0:3]
print(l3)

li = ['alex', 'wusir', 'egon', '女神', 'taibai']

# 增加 append insert,append在列表最后位置添加,insert在制定列表下表位置添加
li.append('日天')
li.append(1)
print(li)

li.insert(4, '春哥')
print(li)
li.extend('二哥')
li.extend([1, 2, 3])
print(li)

# 删pop()默认删除最后一个
li = ['taibai', 'alex', 'wusir', 'egon', '女神', ]
name = li.pop(1)  # 返回值
name = li.pop()
print(name, li)
# 按元素去删除
li.remove('taibai')
print(li)

li.clear()  # 清空
print(li)

del li
del li[0:2]  # 切片去删除
print(li)

# 改
li[0] = '男兽'
li[0] = [1, 2, 3]
切片
li[0:3] = '云姐plfdslkmgdfjglk'
li[0:3] = [1, 2, 3, '春哥', '咸鱼哥']
print(li)

# 查
for i in li:
    print(i)
print(li[0:2])

# 公共方法：
l = len(li)
print(l)
num = li.count('taibai')
print(num)
print(li.index('wusir'))

li = [1, 5, 4, 7, 6, 2, 3]
# 正向排序
li.sort()
print(li)
# 反向排序
li.sort(reverse=True)
print(li)
# 反转,倒过来输出
li.reverse()
print(li)

# 列表的嵌套
li = ['taibai', '武藤兰', '苑昊', ['alex', 'egon', 89], 23]
print(li[1][1])
name = li[0].capitalize()
# print(name)
li[0] = name
li[0] = li[0].capitalize()
li[2] = '苑日天'
print(li[2].replace('昊', 'ritian'))
li[2] = li[2].replace('昊', 'ritian')
li[3][0] = li[3][0].upper()
print(li)

 

其他操作。

count（数）（方法统计某个元素在列表中出现的次数）。

1 a = ["q","w","q","r","t","y"]
2 print(a.count("q"))

index（方法用于从列表中找出某个值第一个匹配项的索引位置）

1 a = ["q","w","r","t","y"]
2 print(a.index("r"))

 

字典dict

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

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

 

字典增删改查操作

"""
#数据类型划分：可变数据类型，不可变数据类型
不可变数据类型：元组，bool int str       可哈希
可变数据类型：list，dict set             不可哈希
dict key 必须是不可变数据类型，可哈希，
    value：任意数据类型。
dict 优点：二分查找去查询
         存储大量的关系型数据
      特点：无序的
"""
dic = {
    'name': ['大猛', '小孟'],
    'py9': [{'num': 71, 'avg_age': 18, },
            {'num': 71, 'avg_age': 18, },
            {'num': 71, 'avg_age': 18, },
            ],
    True: 1,
    (1, 2, 3): 'wuyiyi',
    2: '二哥',
}
print(dic)

# 增
dic1 = {'age': 16, 'name': 'jin', 'sex': 'male', 'high': 185}
dic1.setdefault('weight')  # 有键值对，不做任何改变，没有才添加。
dic1.setdefault('weight', 150)
dic1.setdefault('name', '二哥')
print(dic1)

# 删
print(dic1.pop('age'))  # 有返回值，按键去删除
print(dic1.pop('二哥', None))  # 可设置返回值
print(dic1)

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

del dic1['name1']
print(dic1)
del dic1
print(dic1)
dic1.clear()  # 清空字典

# 改  update
dic1['age'] = 16

dic = {"name": "jin", "age": 18, "sex": "male"}
dic2 = {"name": "alex", "weight": 75}
# dic2的值改变了,dic的值不变，如果dic2的key与dic中的key相同用dic的key,value,
dic2.update(dic)
print(dic)
print(dic2)

# 查
dic1 = {'age': 18, 'name': 'jin', 'sex': 'male', }
print(dic1.keys(), type(dic1.keys()))
print(dic1.values())
print(dic1.items())

for i in dic1:
    print(i)
for i in dic1.keys():
    print(i)

for i in dic1.values():
    print(i)

a, b = 1, 2
print(a, b)

a = 1
b = 2
a, b = b, a
print(a, b)
a, b = [1, 2], [2, 3]
a, b = (1, 2)
print(a, b)

for k, v in dic1.items():
    print(k, v)

v1 = dic1['name']
print(v1)

v2 = dic1['name1']  # 报错
print(v2)

print(dic1.get('name1', '没有这个键'))

 

基础数据类型的总结

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

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

按存值个数区分

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

 

 

按可变不可变区分

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

 

 

按访问顺序区分

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

 

 

 

其他（for，enumerate，range）。

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)

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)　　

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)