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

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

二进制 十进制转换

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

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

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

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

1 s = 'oldboy'
2 # * capitalize 首字母大写，其他字母小写
3 s1 = s.capitalize()
4 print(s1)
5 # ***  upper 全部大写 lower 全部小写  输入验证码不区分大小写
6 s2 = s.upper()
7 print(s2)
8 s3 = s.lower()
9 print(s3)
#登录验证免大小写
1 code = 'QeaR'.upper()
2 you_code = input('请输入你的验证码：').upper()
3 if code == you_code:
4 　　print('验证成功')
1 s = 'oldboy'
2 #大小写翻转
3 s4 = s.swapcase()
4 print(s4)
大小写翻转
1 s = 'alex wusir*oldboy%taibai'
2 s5 = s.title()
3 print(s5)
非字母隔开的每个单词首字母大写
 1 s = 'oldboy'
 2 #cengter 居中 后边默认填充为None
 3 s6 = s.center(30,'*'）
 4 print（s6）
 5 
 6 
 7 #startswith、endswith 以什么为开头和以什么为结尾 有切片功能
 8 #s7 = s.startswith('o')
 9 s7 = s.startswith('ol')
10 print(s7)
11 
12 s8 = s.startswith('l',3,5)
13 print(s8)
***center居中、startswith开始、endswith结束
***strip去除首尾的空格，制表符、换行符

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

去除左边的元素使用 lstrip 

去除右边的元素使用 rstrip

 1 s = 'oldboy wusir alex'
 2 #默认空格隔开，可以添加分隔符
 3 l = s.split()
 4 print(l)
 5 s1 =  'oldboy,wusir,alex'
 6 l1 =  = s.split(',')
 7 print(l1)
 8 s2 = 'oldboywusiroalex'#['', 'ldb', 'ywusir', 'alex']
 9 l2 = s2.split('o')
10 print(l2)
***split (str----->list)可以直接把字符串转换成列表便于使用
1 s = 'oldboy'
2 s9 = '+'.join(s) #可迭代的 使用+逐次插到字符串形成新的字符串
3 print(s9)
4 l1 = ['oldboy','wusir','alex']
5 s91 = '_'.join(l1)
6 print(s91)
join将列表转换成字符串（list------->str）

split 可以添加切割次数

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

print(l2)

1 s = '我是你兄弟，你竟然说我是你爸爸'
2 s10 = s.replace('你','你们')
3 print(s10)
replace替换
1 s = 'oldoy'
2 ind = s.find('d')   #可以切片 find 通过元素找索引
3 print(ind)
4 ind1 = s.index('a')
5 print(ind1)
6 #区别 两个查找用find  使用index会报错
find index定位,找到第一个之后结束
1 #len count
2 s = 'asdasadsaddddddddddddd'
3 print(len(s))
4 s1 = 'dsasdadsasdasa'
5 print(s.count('d')
公共方法len和count：list，tuple，str
1 #格式化输出format 可以根据索引替换，可以指定替换
2 res='我叫{}今年{}岁，爱好{}'.format('egon',18,'male')
3 print(res)
4 res='我叫{0}今年{1}岁，爱好{2},我依然叫{0}'.format('egon',18,'male')
5 print(res)
6 res='{name} {age} {sex}'.format(sex='male', name='egon', age=18)
7 print(res)
格式化输出format
 1 i = '123'
 2 if i.isdigit():
 3     i = int(i）
 4 else:
 5     print('cuole')
 6 
 7 # name = 'jinxin123'
 8 # print(name.isalnum()) #字符串由字母或数字组成
 9 # print(name.isalpha()) #字符串只由字母组成
10 # print(name.isdigit()) #字符串只由数字组成
11 # i = '123a'
12 # if i.isdigit():
13 #     i = int(i)
14 # else:
15 #     print("输入有误...")
isalnum字母和数字,isalpha字母,isdigit数字-----判断是否由该元素组成

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 　　储存大量的数据

1 li = [111,'alex',222,'wusir']
2 print(li[1]) #alex
3 print(li[-1]) #wusir
4 print(li[:2]) #[111,'alex']
list的索引
 1 l = ['老男孩','alex','wusir','taibai','ritian']
 2 #append
 3  l.append('葫芦') #在最后追加一个元素
 4 print(l)
 5 l.append([1,2,3])#保留追加元素的信息
 6 print(l)
 7 #insert
 8 l.insert(1,'jingnvshen')#在某索引元素后插入一个元素
 9 print(l)
10 #extend 迭代追加
11 l.extend('alex') #把alex元素分解之后插入到列表里
12 print(l)
list增append追加,insert插入，extend跌打追加
 1 l = ['老男孩', 'alex', 'wusir', 'taibai', 'ritian']
 2  #pop 有返回值  按照索引删除
 3 print(l.pop(0))
 4 print(l)
 5 
 6 #remove 按照索引删除
 7 l.remove('alex')
 8 print(l)
 9 
10 #clear 清空列表
11 l.clear()
12 print(l)
13 
14 #del 内存级别删除列表 所有删除操作可以使用del
15 del l
16 print(l)
17 #按索引删除
18 del l[1]
19 print(l)
20 #切片删除
21 del l[:3]
22 print(l)
删（pop，remove，clear，del）
 1 l = ['老男孩', 'alex', 'wusir', 'taibai', 'ritian']
 2 #按照索引改
 3 print(l[2])
 4 l[2] = '武藤兰'
 5 print(l)
 6 
 7 #按照切片去改 把原有元素删除，把现有元素按照最小元素一次添加进去
 8 #也可以看做是替换操作
 9 l[:2] = 'abc'
10 print(l)
11 l[1:3] = [111,222,333,444]
12 print(l)
改（重新赋值）
1 l = ['老男孩','wusir','taibai','eitian']
2 #按照索引查询
3 #按照切片查询
4 #循环查询for
5 for i in l:
查
 1 l1 = [1,2,1,2,1,1,3,4]
 2 print(l1.count(1))
 3 print(len(l1))
 4 
 5 #index通过元素找索引 列表只有index没有find
 6 print(l1.index(2))
 7 
 8 #sort 排序 从小到大  修改sort里的参数就可以从大到小排序
 9 l2 = [2,3,4,6,9,8,7,1]
10 l2.sort()
11 print(l2)
12 l2.sort(reverse=Ture)
13 print(l2)
14 
15 #reverse
16 l2.reverse()
17 print(l2)
其他方法count,len,index
1 l2 = [1,2,4,6,7,3,9]
2 l2.sort()
3 print(l2)
4 l2.sort(reverse=Ture)
5 print(l2) #从大到小
6 l2.reverse()
7 print(l2)
sort排序reverse倒序排序
 1 l1 = [1,3,'alex','wusir',[1,5,8,'oldboy'],'ritian']
 2 #1、将alex全部变成大写放回原处，两种方法
 3 l1[2] = l1[2].upper()
 4 print(l1)
 5 l1[2] = 'al'
 6 print(l1)
 7 #2、给[[]]里追加一个元素叫女神
 8 l1[4].append('nvshen')
 9 print(l1)
10 
11 #3、将ritian首字母大写放回原处
12 l1[5] = l1[5].capitalize()
13 print(l1)
14 #4、将8通过数字相加，或者字符串相加或者等等，变成‘50’
15 l1[4][1] = str(l1[4][1]) + '0'
16 print(l1)
列表的嵌套

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

 1 tu = (2,3,4,'alex',{'name':'oldboy'},{1,2,3,},(1,2,3),{'wusir'})
 2 for i in tu:
 3     print(i)
 4 
 5 print(tu[1])
 6 
 7 print(tu[:2:2])#切片查 步长查
 8 
 9 print(tu.index(Ture)） #查
10 
11 print(tu.count(2)) #计数
12 
13 print(len(tu))    #长度
14 
15 tu[-3].append(666)
16 print(tu)
tuple操作

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。

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

1 dic = {'name':'taibai','age':21,'hobby':'girl'}
2 #增 在python3.6之前字典是无序的，在3.6之后有序
3 dic['high'] = 180
4 print(dic)
5 #如果增加的时候有该键值对，那就直接修改
6 dic.setdefault('high',180)
7 print(dic)
8 #setdefault 有则不变，无则添加 如果不想变动字典的元素，可以使用
字典的增setdefault和改，有则覆盖，无则添加
 1 dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
 2 #pop
 3 dic.pop('name') #字典的操作都是根据键操作 可以类比于列表的索引
 4 print(dic)
 5 #如果该字典里没有该键值对，可以在后边添加None不报错
 6 pint(dic.pop('name'，None)) 
 7 print(dic)
 8 
 9 #clear 清空
10 dic.clear()
11 print(dic)
12 
13 #del  内存中删除
14 del dic
15 print(dic)
16 
17 #del的删除
18 del dic{'name')
19 print(dic)
20 
21 #popitem  #随机删除，3.6之后删除最后  有返回值，删除什么返回什么
22 dic.popitem()
23 print(dic)
字典的删（pop clear del popitem）
1 dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
2 dic['name'] = 'odlboy'
3 print(dic)
4 
5 #update 更新 将dic的键值对覆盖添加到dic2中
6 dic2 = {'name':'ritian','weigth':75}
7 dic2.update(dic)
8 print(dic2)
dict的改
 1 dic = {'name': 'taibai', 'age': 21, 'hobby': 'girl', }
 2 #基本的查 没有该键值对有报错
 3 print(dic['name'])
 4 
 5 #get 无报错查找
 6 print(dic.get('name'))
 7 
 8 #keys()  values()  items() 查所有的键值对 元素 组 可以转换成列表
 9 print(list(dic.keys()))
10 for i in dic.keys():
11     print(i)
12 print(list(dic.values()))
13 for i in dic.values():
14     print(i)
15 print(list(dic.items()))
16 for i in dic.items():
17     print(i)
18 for k,v in dic.items():
19     print(k,v)
20 #分别赋值 必须一一对应
21 a,b = 1,2
22 a,b,c = ['alex','eitian','wusir']
23 
24 #面试：
25 a = 1 b = 5 #用一行代码将a，b值互换
26 a,b = b,a
27 print(a,b)
28 
29 #len
30 print(len(dic))
31 
32 #fromkeys 创建一个新的字典
33 dic1 = dict.fromkeys('abc','zhangsan')
34 dic2 = dict.fromkeys([1,2,3,],'zhangsan')
35 print(dic1)
36 print(dic2)
37 
38 dic3 = dict.fromkeys('abc',[])
39 print(dic3)
40 dic3['a'].append('laonanhai')#修改一个元素会修改三个。
41 print(dic3)
dict的查get，for循环查 分别赋值
 1 dic = {
 2     'name_list':['b哥', '张帝', '人帅', 'kitty'],
 3     '老男孩':{
 4         'name':'老男孩',
 5         'age': 46,
 6         'sex': 'ladyboy',
 7     },
 8 }
 9 #1，['b哥', '张帝', '人帅', 'kitty']列表追加一个元素，'骑兵'
10 dic['name_list'].append('骑兵')
11 print(dic)
12 #2将kitty全部变成大写
13 dic['name_list'][-1] = dic['name_list'][-1].upper()
14 print(dic)
15 #3将老男孩改成oldboy
16 dic['老男孩']['name'] = 'oldboy'
17 print(dic)
18 #4将ladyboy首字母大写
19 dic['老男孩']['sex'] = dic['老男孩']['sex'].capitalize()
20 print(dic)
字典的嵌套

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

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

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

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

 1 l1 = [1,1,3,4,5,6,6,7,]
 2 set1 = list(set(l1))
 3 print(set1)
 4 
 5 #add
 6 set1.add('666')  #增 无序的
 7 print(set1)  
 8 
 9 #update
10 set1.update('abd')
11 print(set1)
12 
13 #remove  clear del pop随机删除
set集合 增 删 查
 1 交集 &  intersectio
 2 print(set1 & set2)
 3 print(set1.intersection(set2))
 4 
 5 并集 |   union
 6 print(set1 | set2)
 7 print(set1.union(set2))
 8 
 9 差集  -  difference
10 print(set1 - set2)
11 print(set1.difference(set2))
12 
13 反交集 ^ symmetric_difference
14 print(set1 ^ set2)
15 print(set1.symmetric_difference(set2))  # {1, 2, 3, 6, 7, 8}
16 set1 = {1,2,3}
17 set2 = {1,2,3,4,5,6}
18 
19 print(set1 < set2)
20 print(set1.issubset(set2))  # 这两个相同，都是说明set1是set2子集。
21 
22 print(set2 > set1)
23 print(set2.issuperset(set1))
24 
25 s = frozenset('barry')
26 s1 = frozenset({4,5,6,7,8})
27 print(s,type(s))
28 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做转化然后存储传输

 1 #编码的转化 :编码encode和解码decode
 2 s = 'laonanhai'
 3 s2 = s.encode('utf-8')  #str----->bytes  encode
 4 s3 = s.encode('gbk')
 5 print(s2,s3)
 6 
 7 s = '中国'
 8 s2 = s.encode('utf-8') 
 9 s3 = s.encode('gbk')
10 print(s2,s3)
11 
12 s4 = s2.decode('utf-8')  #bytes----->str decode 解码
13 print(s4)

 

9、bytes

1 #bytes类型 对于英文来说
2 s = 'laonanhai'   #表现形式  内部编码方式为：Unicode
3 print(s,type(s))
4 
5 s1 = b'laonanhai' #表现形式  内部编码方式为：非Unicode（utf-8，gbk...）
6 print(s1,type(s1))
1 #bytes类型 对于中文
2 s = '中国‘’
3 print(s,type(s))
4 
5 s1 = b'\xe4\xb8\xad\xe5\x9b\xbd'
6 print(s1,type(s1))

10、数据类型的补充

 1 l1 = ['alex','wusir','taibai','barry','老男孩']
 2 
 3 #将奇数位元素删除
 4 del l1[1::2]
 5 print(li)
 6 
 7 #错误的事例
 8 for i in l1:
 9     if l1.index(i) % 2 == 1:
10         del l1[ l1.index(i)]
11 print(l1)
12 #原因说明：再循环一个列表时，不要对列表进行删除的动作
13 #改变了列表的元素个数（索引改变），会出错。
14 #倒着删除
15 for i in range(len(l1)-1,-1,-1):
16             if i % 2 == 1:
17                  del l1[i]
18 print(l1)
19 #range  可定制的数字列表 还可以加步长 还可以倒着 用于for循环
20 for i in range(0,10,2):
21     print(i)
22 for i in range(10,2,-1):
23     print(i)
24 
25 #字典 dict 再循环字典时不要改变的大小。删除或增加
26 dic = {'k1':'v1','k2':'v2','k3':'v3','r':666}
27 l2 = []
28 for i in dic:
29     if 'k' in  i:
30         l2.append(i)
31 print(l2)
32 for i in l2:
33     del dic[i]
34 print(dic)
35 
36 
37 #元组tuple  如果元组里面只有一个元素并且没有逗号隔开，那么他的数据类型是该元素一致   个人理解是因为（）包裹填写变量的时候有无该括号没影响，添加上逗号或者其他之后才会认为是一个元组。
38 tu1 = (1) 
39 print(tu1,type(tu1))
40 tu2 = ('alex')
41 print(tu2,type(tu2))
 1 #id 内存 一定要在终端测试
 2 a = 'alex'
 3 b = 'alex'
 4 print(a == b) #数值比较
 5 print(a is b)    #内存地址比较
 6 
 7 #小数据池int str
 8 #int -5 ~ 256 的相同的数全都指向一个内存地址，节省空间
 9 a = 3
10 b = 3
11 print(a is b)
12 #str  s = 'a' * 20 以内都是同一个内存地址
13 #字符串含有非字母的，就不共用一个内存地址

11 深浅copy

1 #赋值运算，他们共用一个列表
2 a = [1,2,3]
3 b =a
4 a.append(666)
5 print(a,b)
1 #浅copy  创建两个内存地址。
2 l1 = [1,2,3]
3 l2 = l1.copy()
4 l1.append(666)
5 print(l1,l2)
1 #浅copy 对于父层来说用两个内存地址，但是对于子层来说共用一个内存地址
2 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，判断，范围。
    购买成功，打印购买的商品列表

'''
posted @ 2018-04-10 15:57  张腾飞♂  阅读(154)  评论(0)  编辑  收藏  举报