python自动化_day2_基础数据类型0410

1、int  　　1,2,3,4....用于计算，运算

二进制 十进制转换

2、str　　‘老男孩’，‘alex’，少量的数据的存储

s = 'python自动化运维21期'
s1 = s[0]
print(s1)
s2 = s[2]
print(s2)
s3 = s[-1]
print(s3)
s4 = s[-2]
print(s4)

s = 'python自动化运维21期'
s1 = s[0:6] #顾首不顾尾 意思就是从第一开始必须到最后一个的下一位 
print(s1)
s2 = s[6:9]
print(s2)
s3 = s[:5:2]
print(s3)
s4 = s[:]
print(s4)
s5 = s[-1:-5:-1] #必须加一个反向步长
print(s5)

　　切片: s [起始索引:结束索引+1:步长]

　　capitalize首字母大写，upper全部大写，lower全部小写

s = 'oldboy'
# * capitalize 首字母大写，其他字母小写
s1 = s.capitalize()
print(s1)
# ***  upper 全部大写 lower 全部小写  输入验证码不区分大小写
s2 = s.upper()
print(s2)
s3 = s.lower()
print(s3)

#登录验证免大小写
1 code = 'QeaR'.upper()
you_code = input('请输入你的验证码：').upper()
if code == you_code:
　　print('验证成功')

s = 'oldboy'
#大小写翻转
s4 = s.swapcase()
print(s4)

s = 'alex wusir*oldboy%taibai'
s5 = s.title()
print(s5)

s = 'oldboy'
#cengter 居中 后边默认填充为None
s6 = s.center(30,'*'）
print（s6）


#startswith、endswith 以什么为开头和以什么为结尾 有切片功能
#s7 = s.startswith('o')
s7 = s.startswith('ol')
print(s7)

s8 = s.startswith('l',3,5)
print(s8)

***

strip不止可以去除空格，换行符，制表符，还可以规定去除首尾的匹配字符（迭代去除）

去除左边的元素使用 lstrip 

去除右边的元素使用 rstrip

s = 'oldboy wusir alex'
#默认空格隔开，可以添加分隔符
l = s.split()
print(l)
s1 =  'oldboy,wusir,alex'
l1 =  = s.split(',')
print(l1)
s2 = 'oldboywusiroalex'#['', 'ldb', 'ywusir', 'alex']
l2 = s2.split('o')
print(l2)

s = 'oldboy'
s9 = '+'.join(s) #可迭代的 使用+逐次插到字符串形成新的字符串
print(s9)
l1 = ['oldboy','wusir','alex']
s91 = '_'.join(l1)
print(s91)

split 可以添加切割次数

l2 = s.split('o',1) #['','ldboywusiralex']

print(l2)

s = '我是你兄弟，你竟然说我是你爸爸'
s10 = s.replace('你','你们')
print(s10)

s = 'oldoy'
ind = s.find('d')   #可以切片 find 通过元素找索引
print(ind)
ind1 = s.index('a')
print(ind1)
#区别 两个查找用find  使用index会报错

#len count
s = 'asdasadsaddddddddddddd'
print(len(s))
s1 = 'dsasdadsasdasa'
print(s.count('d')

#格式化输出format 可以根据索引替换，可以指定替换
res='我叫{}今年{}岁，爱好{}'.format('egon',18,'male')
print(res)
res='我叫{0}今年{1}岁，爱好{2},我依然叫{0}'.format('egon',18,'male')
print(res)
res='{name} {age} {sex}'.format(sex='male', name='egon', age=18)
print(res)

i = '123'
if i.isdigit():
    i = int(i）
else:
    print('cuole')

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

3、bool：True  Fales

　　int -------> str(int)  

　　str-------->int(str) str必须是数字组成

　　int---------> bool 0 False 非0 Ture

　　bool-------> int int(Ture)  1     int(False) 0

　　str -------->bool  '' False  '   '非空 True

4、list 　　储存大量的数据

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

l = ['老男孩','alex','wusir','taibai','ritian']
#append
 l.append('葫芦') #在最后追加一个元素
print(l)
l.append([1,2,3])#保留追加元素的信息
print(l)
#insert
l.insert(1,'jingnvshen')#在某索引元素后插入一个元素
print(l)
#extend 迭代追加
l.extend('alex') #把alex元素分解之后插入到列表里
print(l)

l = ['老男孩', 'alex', 'wusir', 'taibai', 'ritian']
 #pop 有返回值  按照索引删除
print(l.pop(0))
print(l)

#remove 按照索引删除
l.remove('alex')
print(l)

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

#del 内存级别删除列表 所有删除操作可以使用del
del l
print(l)
#按索引删除
del l[1]
print(l)
#切片删除
del l[:3]
print(l)

l = ['老男孩', 'alex', 'wusir', 'taibai', 'ritian']
#按照索引改
print(l[2])
l[2] = '武藤兰'
print(l)

#按照切片去改 把原有元素删除，把现有元素按照最小元素一次添加进去
#也可以看做是替换操作
l[:2] = 'abc'
print(l)
l[1:3] = [111,222,333,444]
print(l)

l = ['老男孩','wusir','taibai','eitian']
#按照索引查询
#按照切片查询
#循环查询for
for i in l:

l1 = [1,2,1,2,1,1,3,4]
print(l1.count(1))
print(len(l1))

#index通过元素找索引 列表只有index没有find
print(l1.index(2))

#sort 排序 从小到大  修改sort里的参数就可以从大到小排序
l2 = [2,3,4,6,9,8,7,1]
l2.sort()
print(l2)
l2.sort(reverse=Ture)
print(l2)

#reverse
l2.reverse()
print(l2)

l2 = [1,2,4,6,7,3,9]
l2.sort()
print(l2)
l2.sort(reverse=Ture)
print(l2) #从大到小
l2.reverse()
print(l2)

l1 = [1,3,'alex','wusir',[1,5,8,'oldboy'],'ritian']
#1、将alex全部变成大写放回原处，两种方法
l1[2] = l1[2].upper()
print(l1)
l1[2] = 'al'
print(l1)
#2、给[[]]里追加一个元素叫女神
l1[4].append('nvshen')
print(l1)

#3、将ritian首字母大写放回原处
l1[5] = l1[5].capitalize()
print(l1)
#4、将8通过数字相加，或者字符串相加或者等等，变成‘50’
l1[4][1] = str(l1[4][1]) + '0'
print(l1)

5、tuple 　　只读列表 元组 元组不可以修改，不过元组里面的元素的数据可以修改

tu = (2,3,4,'alex',{'name':'oldboy'},{1,2,3,},(1,2,3),{'wusir'})
for i in tu:
    print(i)

print(tu[1])

print(tu[:2:2])#切片查 步长查

print(tu.index(Ture)） #查

print(tu.count(2)) #计数

print(len(tu))    #长度

tu[-3].append(666)
print(tu)

6、dict 　　　以键值对的形式存在，储存大量的关联性数据 查询速度非常快，符合二分查找

　　{'name':'oldboy','age':12,'name_list':['zhangsan','lisi','wangwu']}　　

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

　　key：不可变的数据类型（可哈希）：str， bool， tuple， int。

　　value：任意数据类型。

　　数据类型分类：

　　　　　　　　不可变的数据类型（可哈希）：str， bool， tuple， int。

　　　　　　　　可变的数据类型：dict，list，set。

　　　　　　　　容器类数据类型：list ，tuple，dict，set。

　　字典；存储数据多，关系型数据，查询速度快。（二分查找）

dic = {'name':'taibai','age':21,'hobby':'girl'}
#增 在python3.6之前字典是无序的，在3.6之后有序
dic['high'] = 180
print(dic)
#如果增加的时候有该键值对，那就直接修改
dic.setdefault('high',180)
print(dic)
#setdefault 有则不变，无则添加 如果不想变动字典的元素，可以使用

dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
#pop
dic.pop('name') #字典的操作都是根据键操作 可以类比于列表的索引
print(dic)
#如果该字典里没有该键值对，可以在后边添加None不报错
pint(dic.pop('name'，None)) 
print(dic)

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

#del  内存中删除
del dic
print(dic)

#del的删除
del dic{'name')
print(dic)

#popitem  #随机删除，3.6之后删除最后  有返回值，删除什么返回什么
dic.popitem()
print(dic)

dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
dic['name'] = 'odlboy'
print(dic)

#update 更新 将dic的键值对覆盖添加到dic2中
dic2 = {'name':'ritian','weigth':75}
dic2.update(dic)
print(dic2)

dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
#基本的查 没有该键值对有报错
print(dic['name'])

#get 无报错查找
print(dic.get('name'))

#keys()  values()  items() 查所有的键值对 元素 组 可以转换成列表
print(list(dic.keys()))
for i in dic.keys():
    print(i)
print(list(dic.values()))
for i in dic.values():
    print(i)
print(list(dic.items()))
for i in dic.items():
    print(i)
for k,v in dic.items():
    print(k,v)
#分别赋值 必须一一对应
a,b = 1,2
a,b,c = ['alex','eitian','wusir']

#面试：
a = 1 b = 5 #用一行代码将a，b值互换
a,b = b,a
print(a,b)

#len
print(len(dic))

#fromkeys 创建一个新的字典
dic1 = dict.fromkeys('abc','zhangsan')
dic2 = dict.fromkeys([1,2,3,],'zhangsan')
print(dic1)
print(dic2)

dic3 = dict.fromkeys('abc',[])
print(dic3)
dic3['a'].append('laonanhai')#修改一个元素会修改三个。
print(dic3)  

dic = {
    'name_list':['b哥', '张帝', '人帅', 'kitty'],
    '老男孩':{
        'name':'老男孩',
        'age': 46,
        'sex': 'ladyboy',
    },
}
#1，['b哥', '张帝', '人帅', 'kitty']列表追加一个元素，'骑兵'
dic['name_list'].append('骑兵')
print(dic)
#2将kitty全部变成大写
dic['name_list'][-1] = dic['name_list'][-1].upper()
print(dic)
#3将老男孩改成oldboy
dic['老男孩']['name'] = 'oldboy'
print(dic)
#4将ladyboy首字母大写
dic['老男孩']['sex'] = dic['老男孩']['sex'].capitalize()
print(dic)

7、set集合　　　　关系型数据的交集，并集，差集，子集.....可以用于列表的去重

集合：无序的不重复的数据类型。它里面的元素必须是不可变的（可哈希的），但是集合本身是可变的（不可哈希的）

　　1.关系测试：交集，并集，差集，子集

　　2.去重。（列表的去重）

l1 = [1,1,3,4,5,6,6,7,]
set1 = list(set(l1))
print(set1)

#add
set1.add('666')  #增 无序的
print(set1)  

#update
set1.update('abd')
print(set1)

#remove  clear del pop随机删除

交集 &  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、编码

ASCII：字母 数字  特殊字符

　　　　万国码：unicode：

　　　　　　　　A:0000 0001 0000 0001 两个字节表示一个字符,字符：组成元素的最小单元

　　　　　　　　中：0000 0001 0000 0001 两个字节表示一个字符 ☆中国汉字超过65535种

　　　　升级：

　　　　　　　　A:0000 0001 0000 0001 0000 0001 0000 0001 四个字节表示一个字符

　　　　　　　　中:0000 0001 0000 0001 0000 0001 0000 0001 四个字节表示一个字符

　　　　utf-8：最少用一个字节，表示一个字符：

　　　　　　　　A:0000 0001

　　　　　　　　欧洲：0000 0001 0000 0001

　　　　　　　　中文：0000 0001 0000 0001 0000 0001

　　　　gbk国标：

　　　　　　　　英文:0000 0001

　　　　　　　　中文：0000 0001 0000 0001

　　python3x：

　　　　1、不同编码之间的二进制是不能互相识别的

　　　　2、python3x str内部编码为（内存）Unicode

　　　　　　但是，对于文件的存储和传输，不能用Unicode

　　　　　　bytes类型，内部编码方式为非Unicode

编码的转化，因为传输和存储不能用Unicode，而str类型只有Unicode，所以需要借用bytes做转化然后存储传输

#编码的转化 :编码encode和解码decode
s = 'laonanhai'
s2 = s.encode('utf-8')  #str----->bytes  encode
s3 = s.encode('gbk')
print(s2,s3)

s = '中国'
s2 = s.encode('utf-8') 
s3 = s.encode('gbk')
print(s2,s3)

s4 = s2.decode('utf-8')  #bytes----->str decode 解码
print(s4)

9、bytes

#bytes类型 对于英文来说
s = 'laonanhai'   #表现形式  内部编码方式为：Unicode
print(s,type(s))

s1 = b'laonanhai' #表现形式  内部编码方式为：非Unicode（utf-8，gbk...）
print(s1,type(s1))

#bytes类型 对于中文
s = '中国‘’
print(s,type(s))

s1 = b'\xe4\xb8\xad\xe5\x9b\xbd'
print(s1,type(s1))

10、数据类型的补充

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

#将奇数位元素删除
del l1[1::2]
print(li)

#错误的事例
for i in l1:
    if l1.index(i) % 2 == 1:
        del l1[ l1.index(i)]
print(l1)
#原因说明：再循环一个列表时，不要对列表进行删除的动作
#改变了列表的元素个数（索引改变），会出错。
#倒着删除
for i in range(len(l1)-1,-1,-1):
            if i % 2 == 1:
                 del l1[i]
print(l1)
#range  可定制的数字列表 还可以加步长 还可以倒着 用于for循环
for i in range(0,10,2):
    print(i)
for i in range(10,2,-1):
    print(i)

#字典 dict 再循环字典时不要改变的大小。删除或增加
dic = {'k1':'v1','k2':'v2','k3':'v3','r':666}
l2 = []
for i in dic:
    if 'k' in  i:
        l2.append(i)
print(l2)
for i in l2:
    del dic[i]
print(dic)


#元组tuple  如果元组里面只有一个元素并且没有逗号隔开，那么他的数据类型是该元素一致   个人理解是因为（）包裹填写变量的时候有无该括号没影响，添加上逗号或者其他之后才会认为是一个元组。
tu1 = (1) 
print(tu1,type(tu1))
tu2 = ('alex')
print(tu2,type(tu2))

#id 内存 一定要在终端测试
a = 'alex'
b = 'alex'
print(a == b) #数值比较
print(a is b)    #内存地址比较

#小数据池int str
#int -5 ~ 256 的相同的数全都指向一个内存地址，节省空间
a = 3
b = 3
print(a is b)
#str  s = 'a' * 20 以内都是同一个内存地址
#字符串含有非字母的，就不共用一个内存地址

11 深浅copy

#赋值运算，他们共用一个列表
a = [1,2,3]
b =a
a.append(666)
print(a,b)

#浅copy  创建两个内存地址。
l1 = [1,2,3]
l2 = l1.copy()
l1.append(666)
print(l1,l2)

#浅copy 对于父层来说用两个内存地址，但是对于子层来说共用一个内存地址
l1 = [1,2,3,[2,3]]
3 l2 = l1.copy()
4 l1[-1].append(666)
5 print(l1,l2)
6 print(id(l1[-1]),id(l2[-1]))

#深copy  对于深copy来说，所有都是分开的内存地址
import copy
l1 = [1,2,3,[22,33]]
l2 = copy.deepcopy(l1)
l1[-1].append(777)
print(l1,l2)

12，购物车作业思路

'''
购物车
功能要求：
要求用户输入总资产，例如：2000
显示商品列表，让用户根据序号选择商品，加入购物车
购买，如果商品总额大于总资产，提示账户余额不足，否则，购买成功。
goods = [{"name": "电脑", "price": 1999},
           {"name": "鼠标", "price": 10},
　　　　　　{"name": "游艇", "price": 20},
　　　　　　{"name": "美女", "price": 998},
]
'''

goods = [{"name": "电脑", "price": 1999},
           {"name": "鼠标", "price": 10},
         {"name": "游艇", "price": 20},
         {"name": "美女", "price": 998},]
'''
money = input()
shopping_car = [{name:；电脑，count：3}]
1,展示商品
    1， 电脑 1999
    2， 鼠标 10
    .....
    1,输入的是全部数字
    2，判断，范围。
    购买成功，打印购买的商品列表

'''