python基础数据类型

Posted 2020-10-31 dacheng-tony

python基础-数据类型 

　　python 数据类型包括 数字类型、字符串、列表、元组、字典、集合。

　　1、 int 整数型

　　　　eg：1,2,3 .... 用于计算，运算。　　　

#.bit_length() 将十进制转换为二进制的最小有效位数
i = 3
i = 4
print(i.bit_length())
"""
二进制          十进制
0000 0001          1
0000 0010          2
0000 0011          3
0000 0100          4
"""

　　2、str 字符串 

　　　　eg：　‘老男孩’，‘alex‘.... 可以 少量的数据的存储

　　　2,1 索引（下标）

#字符串是有索引的。什么是索引？ 索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。
s = ‘python自动化运维21期‘
#第一个元素
s1 = s[0]
#第二个元素
print(s1)
s2 = s[2]
print(s2)
#最后一个元素
s3 = s[-1]
print(s3)
#倒数第二个元素
s4 = s[-2]
print(s4)

　　　　2.2 切片

#切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾腚）。
#s[起始索引:结束索引+1:步长]
#想要取到第5位
s1 = s[0:6] #顾头不顾腚
#开头0可以忽略
s1 = s[:6]
print(s1)
#取6位到8位
s2 = s[6:9]
print(s2)
#开头取到第四位，间隔为一，步长就是2
s3 = s[:5:2]
print(s3)
#从头取值到结尾
s4 = s[:]
print(s4)
#倒着取到第四个，步长必须写
s5 = s[-1:-5:-1]  #倒着取值，必须加反向步长
print(s5)

　　　　2.3 操作方法

#对字符串进行操作，形成新的字符串

#常用： 
#全部大写upper() 
#全部小写lower()
s2 = s.upper()
s3 = s.lower()
print(s2,s3)
## 验证密码不区别大小写
code = ‘QeAr‘.upper()
your_code = input(‘请输入验证码:‘).upper()
if your_code == code:
    print(‘验证成功‘)

# center 居中，俩侧进行填充。长度可自己设定，默认填充物None
 s6 = s.center(30)
 s6 = s.center(30,"*")
 print(s6)

#startswith 判断以什么为开头
#endswith 判断以什么为结尾
#也是顾头不顾尾
s = ‘oldBoy‘
*** startswith endswith
s7 = s.startswith(‘o‘)
s7 = s.startswith(‘ol‘)
s7 = s.startswith(‘oldBoy‘)
s7 = s.startswith(‘Bo‘,3,5)
print(s7)
#后期可以根据开头判断走什么业务逻辑

#strip 默认去除首尾的空格，还可以制表符\t,换行符，还可以迭代去除元素
#lstrip() 只去除左边的 
#rstrip() 只去除右边的
s = ‘   oyldBoy   ‘
print(s)
#默认去除首尾的空格
s8 = s.strip()
print(s8)
#去除元素
s81 = s.strip(‘t‘)
print(s81)
#迭代去除元素
s81 = s.strip(‘tey‘)
print(s81)

name = input(‘>>>‘).strip()
if name == ‘oldboy‘:
    print(‘验证成功‘)

#split  (str ---> list)以什么分割，最终形成一个列表此列表不含有这个分割的元素
#以空格 或者以逗号分隔
s1 = ‘oldboy wusir alex‘
s1 = ‘oldboy,wusir,alex‘
l = s.split()
print(l)
l = s1.split(‘,‘)
print(l)
#以o分割 ，最终列表将没有o元素
s = ‘oldboywusiroalex‘
l2 = s.split(‘o‘)  # [‘‘, ‘ldb‘, ‘ywusir‘, ‘alex‘]
print(l2)
# 还可以添加修改的次数
l2 = s.split(‘o‘,1)  # [‘‘, ‘ldboywusiroalex‘]
print(l2)

#join 将list --->str。里面的元素通过连接符形成新的字符串
#缺点：里面有非字符串元素，就会报错
# s9 = ‘+‘.join(s)
# s9 = ‘_‘.join(s)
# print(s9)
# l1 = [‘oldboy‘,‘wusir‘,‘alex‘]
# s91 = ‘_‘.join(l1)
# print(s91)

#replace 替换，可以限制次数
s = ‘大铁锤fdsalj铁锤妹妹范德萨‘
s10 = s.replace(‘铁锤‘,‘钢蛋‘)
print(s10)

#find 通过元素找索引  找不到返回-1
#index 通过元素找索引 找不到报错
ind = s.find(‘d‘)
print(ind)
ind = s.find(‘o‘)
print(ind)
ind = s.find(‘A‘)
print(ind)
ind = s.index(‘A‘)
print(ind)

#公共方法：元组、列表、字符串都可以用的方法
#len 统计有多少个元素
# count  统计元素出现几次
 s = ‘fdsafsdagsdafjdskahdhjlsadhfkj‘
 print(len(s))
 s = ‘fdsadd‘
 print(s.count(‘d‘))

#格式化输出format
res=‘我叫{}今年{}岁，爱好{}‘.format(‘egon‘,18,‘male‘)
print(res)
#可以根据索引进行替换
res=‘我叫{0}今年{1}岁，爱好{2},我依然叫{0}‘.format(‘egon‘,18,‘male‘)
print(res)
#无需注意顺序，可以根据key找到值
res=‘{name} {age} {sex}‘.format(sex=‘male‘, name=‘egon‘, age=18)
print(res)

#is系列
name = ‘jinxin123‘
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成
print(name.isdigit()) #字符串只由数字组成
i = ‘123a‘
if i.isdigit():
    i = int(i)
else:
    print("输入有误...")


#不常用：
# capitalize 首字母大写，其他字母小写
s = ‘oldBoy‘
#capitalize 首字母大写，其他字母小写
s1 = s.capitalize()
print(s1)

#*大小写反转 swapcase()
s4 = s.swapcase()
print(s4)

#非字母的元素隔开的每个单词首字母大写 title()
 s = ‘alex wusir*oldboy3taibia‘
 s5 = s.title()  # Alex Wusir*Oldboy3Taibia
 print(s5)

　　

　　

　　3、bool 布尔值 （True、False）

#数值 字符串 布尔之间转换

#int可以任意转换为str
int  ---> str :str(int)
#str转换为int必须全部是数字组成。
str  ---> int :int(str) 
#int 转换bool
int --- > bool  0 False  非零 True
#bool转换为int
bool ---> int  int(True) 1    int(False)  0
#str转换为bool
str ---> bool  ""为False   非空字符串为True
# print(int(True))
# print(bool("")) # False　　　　

　　4、list 列表 

　　　　eg：[True,1,‘alex‘,{‘name‘:‘oldboy‘},[1,2,3],(2,3,4),{‘wusir‘}]

　　　4.1 列表是有序的，有索引值，可切片，方便取值

li = [111,‘alex‘,222,‘wusir‘]
print(li[1])  # alex
print(li[-1])  # wusir
print(li[:2])  # [111, ‘alex‘]
print(li[:3:2])

　　4.2 增

l = [‘老男孩‘, ‘alex‘, ‘wusir‘, ‘taibai‘, ‘ritian‘]
#append 在最后追加
l.append(‘葫芦‘)  #无返回值，不能打印添加动作
l.append([1,2,3])
print(l)

#insert 插入，任意位置
l.insert(1,‘景nvshen‘)
print(l)

#迭代着添加，必须可迭代，按添加最小元素一一添加进去。
l.extend(‘alex‘)
l.extend([‘111‘,222,333])
print(l)

　　4.3 删

#pop 四种操作唯一有返回值  按照索引删除
print(l.pop(0))
print(l)

#remove 按照元素取删除
l.remove(‘alex‘)
print(l)

#clear 清空列表，还在内存中占着位置
l.clear()
print(l)

#del 内存级别删除列表
del l
print(l)
#按索引删除
del l[1]
print(l)

#切片删除
del l[:3]
print(l)

　　4.4 改

#按照索引改
print(l[2])
l[2] = ‘武藤兰‘
print(l)

#按照切片去改
l[:2] = ‘abc‘ #切面区域都删除，添加按最小元素添加，可以不对等
print(l)
l[1:3] = [111,222,333,444]
print(l)

　　4.5 查

#按照索引去查询，按照切片去查询
for i in l:
    print(i)

l1 = [1,2,1,2,1,1,3,4]

#其他方法：
#count 计数  计算元素个数
print(l1.count(1))

#len 计算多少元素
print(len(l1))

#通过元素找索引，找到第一个就返回
print(l1.index(2))

l2 = [3,2,4,6,9,8,7,1]
#排序
#sort 正序
l2.sort()  从小到大
print(l2)
l2.sort(reverse=True)  #从大到小排序，加参数
print(l2)

#reverse 倒序排列
l2.reverse()
print(l2)

　　　　4.6 列表的嵌套

　

#列表的嵌套
l1 = [1, 2, ‘alfdsafex‘, ‘wusir‘,[‘oldboy‘, ‘ritian‘, 10], ‘taibai‘]
#1,将‘alex‘全部变成大写，放回原处。
l1[2] = ‘ALEX‘ #将单独元素赋值  
print(l1[2].upper())
l1[2] = l1[2].upper()
print(l1)
#2.给[‘oldboy‘, ‘ritian‘, 99] 追加一个元素‘女神’。 一个方法
l1[-2].append(‘女财神‘)
print(l1)
#3，将‘ritian‘首字母大写，放回原处。
l1[-2][1] = l1[-2][1].capitalize()
print(l1)
#4，将10通过数字相加，或者字符串相加或者等等，变成‘100‘
l1[-2][-1] = str(l1[-2][-1] + 90)
print(l1)
#字符串的拼接
l1[-2][-1] = str(l1[-2][-1]) + ‘0‘
print(l1)

　　5、 tuple  元组 只读列表

　　　　eg：(True,1,‘alex‘,{‘name‘:‘oldboy‘},[1,2,3],(2,3,4),{‘wusir‘}) 只读列表

　　　   存放多个值，元组不可变，更多的是用来做查询

　　　　元组本身是不可变的，但是内部的元素可以是可变类型

tu = (11,2,True,[2,3,4],‘alex‘)
#循环去查
for i in tu:
    print(i)
#索引
print(tu[1])
#切片
print(tu[:3:2])
#通过元素找索引
print(tu.index(True))
#元素统计
print(tu.count(2))
print(len(tu))

#内部的元素可以是可变类型
tu[-2].append(666)
print(tu)

　　6、dict 字典 key：value 成对组成的

　　　eg ：{‘name‘:‘oldboy‘,‘age‘:45,‘name_list‘:[‘张三‘....]}　　　　　　

　　　字典的key是唯一的。key 必须是不可变的数据类型。

　　　key:不可变的数据类型(可哈希)：str，bool，tuple，int。

　　　value：任意数据类型。

　　　数据类型分类：

            不可变的数据类型(可哈希)：str，bool，tuple，int
            可变的数据类型：dict，list，set。
            容器类数据类型：list，tuple，dict，set.
　　字典：存储数据多，关系型数据，查询速度快（二分查找）。
　  3.6版本之前，字典是无序的，3.6之后字典是有序的。

　　　　6.1增

#dic[‘high‘] 有则覆盖，无则添加
dic[‘high‘] = 180
dic[‘name‘] = ‘ritian‘
print(dic)
#dic.setdefault() 有则不变，无则添加
dic.setdefault(‘high‘)
dic.setdefault(‘high‘,180)
dic.setdefault(‘name‘,‘日天‘)
print(dic)

　　　　6.2 删

#字典中的key就相当于索引
print(dic.pop(‘name‘))  # 返回值 对应的值
print(dic.pop(‘name1‘,‘没有此key sb‘))#没有name1，删除不报错
print(dic)
print(dic)
dic.clear()  # 清空
print(dic)
print(dic.popitem())  #随机删除，返回值
print(dic)
del dic
print(dic)
del dic[‘age‘]
print(dic)

　　　　6.3 改

dic[‘name‘] = ‘老男孩‘
print(dic)

dic = {"name":"jin","age":18,"sex":"male"}
dic2 = {"name":"alex","weight":75}
dic2.update(dic)  # 将dic的键值对覆盖添加到dic2中，dic不变。
print(dic)
print(dic2)

　　　　6.4 查

#get查询，没有key不报错
print(dic[‘name2‘])
print(dic.get(‘name‘))
print(dic.get(‘name1‘))
print(dic.get(‘name1‘,‘没有此key，sb‘))


#keys() values() items() 字典的转换
#将key转换为列表
print(list(dic.keys()))
for i in dic.keys():
    print(i)
#将value转换为列表
print(dic.values())
for i in dic.values():
    print(i)
#将键值对放到一个元组，元组在构成一个列表
print(list(dic.items()))
for i in dic.items():
    print(i)

#分别赋值
a,b = 1,2
a,b,c = [‘alex‘, ‘wusir‘, ‘ritain‘]
print(a,b,c)
a = 1
b = 5
a,b = b,a
print(a,b)
for i in dic.items():
    print(i)

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

#len 统计键值对个数
print(len(dic))

#fromkeys
dic1 = dict.fromkeys(‘abc‘,‘张三‘)
dic2= dict.fromkeys([1,2,3],‘李四‘)
print(dic2)
#多个都公用一个列表，改一个其他也改
dic3 = dict.fromkeys(‘abc‘,[])
# print(dic3)
dic3[‘a‘].append(‘老男孩‘)
print(dic3)

　　6.5 字典的嵌套

dic = {
    ‘name_list‘:[‘b哥‘, ‘张帝‘, ‘人帅‘, ‘kitty‘],
    ‘老男孩‘:{
        ‘name‘:‘老男孩‘,
        ‘age‘: 46,
        ‘sex‘: ‘ladyboy‘,
    },
}
#1,[‘b哥‘, ‘张帝‘, ‘人帅‘, ‘kitty‘]追加一个元素，‘骑兵‘
dic[‘name_list‘].append(‘骑兵‘)
print(dic)
#2，将kitty全部变成大写。
l1 = dic[‘name_list‘]
print(l1[-1].upper())
l1[-1] = l1[-1].upper()
print(dic)
dic[‘name_list‘][-1] = dic[‘name_list‘][-1].upper()
print(dic)

#3，将老男孩 改成oldboy。
dic[‘老男孩‘][‘name‘] = ‘oldboy‘
print(dic)
，将ladyboy首字母大写。
dic[‘老男孩‘][‘sex‘] = dic[‘老男孩‘][‘sex‘].capitalize()
print(dic)

　　7 set：集合

　　　关系型数据的交集，并集，差集，子集.... 列表的去重。

　　集合：
    无序，不重复的数据类型。它里面的元素必须是可哈希的。但是集合本身是不可哈希的。
    1：关系测试。交集并集，子集，差集....
    2,去重。（列表的去重）

set1 = {1,‘alex‘,False,(1,2,3)}
l1 = [1,1,2,2,3,3,4,5,6,6]
l2 = list(set(l1))
print(l2)

set1 = {‘alex‘,‘wusir‘,‘ritian‘,‘egon‘,‘barry‘}
#增
set1.add(‘666‘)
print(set1)

update
set1.update(‘abc‘)
print(set1)

#删
set1 = {‘alex‘,‘wusir‘,‘ritian‘,‘egon‘,‘barry‘}

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

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

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

del set1  # 删除集合
print(set1)

　　　

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

#交集 &  intersectio
print(set1 & set2)
print(set1.intersection(set2))

#并集 |   union
print(set1 | set2)
print(set1.union(set2))

#差集  -  difference
print(set1 - set2)
print(set1.difference(set2))

#反交集 ^ symmetric_difference
print(set1 ^ set2)
print(set1.symmetric_difference(set2))  # {1, 2, 3, 6, 7, 8}
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))

#不可变几个，让集合变为不可变
s = frozenset(‘barry‘)
s1 = frozenset({4,5,6,7,8})
print(s,type(s))
print(s1,type(s1))

　　8、数据类型的补充

l1 = [‘alex‘, ‘wusir‘, ‘taibai‘, ‘barry‘, ‘老男孩‘]

#删除奇数为元素，切片
del l1[1::2]
print(l1)

#再循环一个列表时，不要对列表进行删除的动作(改变列表元素的个数动作)，会出错
for i in range(len(l1)):
    print(l1)  # [‘alex‘, ‘wusir‘, ‘taibai‘, ‘barry‘, ‘老男孩‘]
                # [‘alex‘, ‘wusir‘, ‘taibai‘, ‘barry‘, ‘老男孩‘]
                # [‘alex‘, ‘taibai‘, ‘barry‘, ‘老男孩‘]
                 # [‘alex‘, ‘taibai‘, ‘barry‘, ‘老男孩‘]
    print(i) # 0 1  2  3
    if i % 2 == 1:
        del l1[i]
    print(l1) # [‘alex‘, ‘wusir‘, ‘taibai‘, ‘barry‘, ‘老男孩‘]
             # [‘alex‘, ‘taibai‘, ‘barry‘, ‘老男孩‘]
            # [‘alex‘, ‘taibai‘, ‘barry‘]
    print(i) # 0 1

#range可定制的数字列表，顾头不顾尾
range 可定制的数字列表
for i in range(10):
    print(i)
for i in range(1,10):
    print(i)
#设置步长
for i in range(1,10,2):
    print(i)
#倒序
for i in range(10,1,-1):
    print(i)
print(range(10))
for i in range(len(l1)-1,-1,-1):
    if i % 2 == 1:
        del l1[i]
print(l1)

dict 再循环字典时，不要改变字典的大小。
dic = {‘k1‘:‘v1‘,‘k2‘:‘v2‘,‘k3‘:‘v3‘,‘r‘:666}
l1 = []
for i in dic:
    if ‘k‘ in i:
        l1.append(i)
# print(l1)

for i in l1:
    del dic[i]
print(dic)

tu 如果元组里面只有一个元素并且没有逗号隔开，那么他的数据类型与该元素一致。
tu1 = (1)
print(tu1,type(tu1))
tu2 = (‘alex‘)
print(tu2,type(tu2))

tu3 = ([‘alex‘,1,2])
print(tu3,type(tu3))

　　9、 作业（购物车）