python自动化开发-[第二天]-基础数据类型与编码(续)

今日简介：

　　　　- 编码

　　　　- 进制转换

　　　　- 初识对象

　　　　- 基本的数据类型

　　　　　　- 整数

　　　　　　- 布尔值

　　　　　　- 字符串

　　　　　　- 列表

　　　　　　- 元祖

　　　　　　- 字典

　　　　　　- 集合

　　　　- range/enumcate

一、编码

　　encode和decode

　　编码就是将字符串转换成字节码，涉及到字符串的内部表示。
　　解码就是将字节码转换为字符串，将比特位显示成字符。

file = '文本'
file.decode(encoding="utf-8", errors="strict")
file.encode(encoding="gbk", errors="strict")

　　encoding为要编码的格式，errors是指的是错误的处理方案

二、进制转换

　　二进制:　　1对应 00000001 3对应 00000011   最多支持2的8次幂

　　八进制：    逢8进1位  1  2 3 4 5 6 7 10

　　十进制       0 1 2 3 4 5 6 7 8 9 10

　　十六进制    逢16进1位  1 2 3 4 5 6 7 8 9 A B C D E F

      各个进制的表示符号

　　b：二进制，o：八进制，d：十进制，x：十六进制 

#二进制
>>> bin(10)
'0b1010'
#十进制转八进制
>>> oct(123)
'0o173'
#十进制转十六进制
>>> hex(10)
'0xa'
#十六进制转二进制

#借助十进制
>>> bin(int('fc',16))
'0b11111100'
#利用函数直接转
>>> bin(0xa)
'0b1010'
>>> oct(0xa)
'012'
>>> hex(10)
'0xa'

　　

三、初识对象 

 

 四、基本数据类型-整数

#1. 当前整数的二进制表示，最少位数
>>> age = 1
>>> print (age.bit_length())
1
#2. 获取当前数据的字节表示
>>> age = 22
#将十进制用16进制展示，\x16放最后
>>> v = age.to_bytes(10,byteorder='big')
>>> print (v)
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16'
#将十进制用16进制展示，\x16放最前
>>> v = age.to_bytes(10,byteorder='little')
>>> print (v)
b'\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00'

五、基本数据类型-布尔

布尔值为False的情况
>>> print (bool(0))
False
>>> print (bool())
False
>>> print (bool(""))
False
>>> print (bool([]))
False

六、基本数据类型-字符串

1、capitalize 将字符串首字母变大写，自身不变会生成一个新的值

例子：

name = 'dragon'
v = name.capitalize()
print (v)
#输出
    Dragon        

 

2、将字符串大写变小写，比lower功能强大，casefold可以将所有语言大写变小写

例子：

name  = 'DragOn'
v = name.casefold()
print(v)
#输出
    dragon

 

3、center将字符串放中心，其余空白用*来替换，字符长度为50

例子：

name = 'dragon'
v = name.center(50,'*')
print(v)
**********************dragon**********************

 

　　

4、count针对字符串里元素出现的次数做计数，支持索引范围

例子：

name = 'dragon'
v = name.count('d')
print (v)

#输出
1

v = name.count('d',1,3)
print (v)
#输出
0

 

　　

5、startswith,从开头匹配字符串，endswith从结尾去匹配字符串,支持索引范围

例子：

name = 'dragon'
v = name.endswith('n',1,2)
print (v)

#输出

False

v = name.startswith('d')
print (v)
#输出
True

 

　　

6、expandtabs将制表符，替换为空白，制表符前面的字符在空白内

例子：

name = 'a\tb\tc\nd\te\tf'
v = name.expandtabs(10)

print (v)

#输出
a         b         c
d         e         f　　

 

　　

7、find和index，find查找不存在值返回-1，index直接报错

例子：

name = 'dragon'
v = name.find('h')  #输出的是索引
print (v)

#输出
-1

name = 'dragon'
v = name.index('r')  #输出的是索引
print (v)
#输出
1

 

　　

8、format格式化输出

例子：

name = '1.%s,2.%s,3.%s'
name = '1.{0},2.{1}.3.{2}'
name.format(1,2,3)
print (name)
#输出
1.{0},2.{1}.3.{2}

name = '1.{name},2.{age},3{ganner}'

name.format_map({'name':'alex','age':18,'ganner':'mid'})
print (name)
#输出
1.{name},2.{age},3{ganner}

name1 = '1.{name},2.{age},3{ganner}'
name.format(name='dragon',age=19,ganner='mid')
print (name)

#输出
1.{name},2.{age},3{ganner}

 

　　

9、isidentifier，判断首个字符是否是字母、下划线开头

例子：

name  = '9dragon'
v = name.isidentifier()
print (v)
#输出
False

name = 'ale'
v = name.isidentifier()
print (v)
#输出
True

 

　　

10、isupper，判断字符串是否全为大写，islower，判断字符串是否全为小写

例子：

name = 'dragon'
v = name.islower()
print (v)

#输出
Ture
name = 'DRAGON'
v = name.isupper()
print (v)
#输出
Ture

 

　　

11、strip移除空白,\n,\t，自定义

例子:

name = 'wonder\t'
v = name.strip() # 空白,\n,\t
print(v)

#输出
wonder

 

12、upper,全部变大写，lower全部变小写

例子：

name = 'alex'
v = name.upper()

print (v)

#输出
      ALEX
name = 'GUEST'
v1 = name.lower()
print (v1)

#输出
    guest

 

13、isprintable,判断字符串是否包含隐藏字符

例子：

name = 'alex\t'
v = name.isprintable()
print (v)

#输出
    Flase

 

14、判断字符串是否为空白，isspace

例子：

name = '    '
v = name.isspace()
print (v)

#输出 
    True

 

15、join字符串拼接

例子：

n = 'time1'
v = '_'.join(n)
print (v)
#输出

    t_i_m_e_1

user_list = ['小花','小明','小强']

for v in user_list:
   h =  '听'.join(user_list)
print (h)

#输出
    小花听小明听小强

 

16、左右填充，ljust,rjust

例子：

name = 'me'
v = name.rjust(20)
print (len(v))

#输出
                  me

 

17、对应关系+翻译--maketrans,translate

例子：

m = str.maketrans('abcde','12345') # 对应关系

name = "akpsojfasdufasdlkfj8ausdfakjsdfl;kjer09asdf"
v = name.translate(m)
print(v)


#输出
kpsojf1s4uf1s4lkfj81us4f1kjs4fl;kj5r091s4f

 

18、大写变小写，小写变大写，swapcase

例子：

name = "Python"
v = name.swapcase()
print(v)
#输出
pYTHON

 

19、replace替换

例子：

name = 'dream'
v = name.replace('dr','st')
print (v)

#输出

steam
 

 

20、partition分割，保留分割符

例子：

 

content = "a|b|c"
v = content.partition('|')  # partition
print(v)

#输出

('a', '|', 'b|c')

 

21、判断是否为数字

例子：

num = '②'
v1 = num.isdecimal()  #'123'
v2 = num.isdigit()    #'123'，'②'
v3 = num.isnumeric()  #'123'，'二'，'②'
print (v1,v2,v3)

 

 

22、isalnum,isalpha

　　isalnum为字符、数字 ，isalpha为字符

例子：

name = 'hello8美女'
v = name.isalnum() #字符，汉子，数字
print (v)
#输出
True
v1 = name.isalpha() #汉子
print (v1)
#输出
False

 

 

 

23、zfill,填充0

例子：

 name = "guest"
 v = name.zfill(20)
 print(v)

#输出
000000000000000guest

 

 

24、split分割，不保留分割符

例子：

name = 'alex|eric'

v = name.split('|')

print (v)

['alex,'eric'']

七、基本数据类型-列表(list)

　　列表是有序可变的，可以增删改查 

1、追加功能

mail_list = ['hele','dream,''google']  #append都是从列表最后添加

v = mail_list.clear()

print (mail_list）

#输出
[]

 

2、清空clear

mail_list = ['hele','dream,''google']  #append都是从列表最后添加

v = mail_list.clear()

print (mail_list）


#输出

[]

3、copy（浅拷贝）

浅拷贝：浅拷贝，只是拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。（浅copy只有最外层会各自不影响，其余都是同一块内存地址,要更改都更改）

深拷贝：深拷贝,拷贝对象及其子对象  （深copy就是所有对象和子对象独立,互相修改没有任何影响）

例子：

user_list = ['a','b','c','d']

浅copy
v = user_list.copy()
print (v)
print (user_list)


#输出

['a', 'b', 'c', 'd']
['a', 'b', 'c', 'd']

 深浅copy的例子:

　　

import copy  
a = [1, 2, 3, 4, ['a', 'b']] #原始对象  
  
b = a #赋值，传对象的引用  
c = copy.copy(a) #对象拷贝，浅拷贝  
d = copy.deepcopy(a) #对象拷贝，深拷贝  
  
a.append(5) #修改对象a  
a[4].append('c') #修改对象a中的['a', 'b']数组对象  
  
print 'a = ', a  
print 'b = ', b  
print 'c = ', c  
print 'd = ', d  

'''
输出结果： 
a = [1, 2, 3, 4, ['a', 'b', 'c'], 5] 
b = [1, 2, 3, 4, ['a', 'b', 'c'], 5] 
c = [1, 2, 3, 4, ['a', 'b', 'c']] 
d = [1, 2, 3, 4, ['a', 'b']]

'''

　　

4、count（计数）

例子：

user_list = ['a','b','c','d']
v =user_list.count('a')
print (v)

#输出

4

 

5、extend扩展原列表

例子：

user_list = ['a','b','c','d']
user_list.extend(['e','f'])
print (user_list)

#输出
['a', 'b', 'c', 'd', 'e', 'f']

 

6、index，查找列表元素，没有报错

例子：

user_list = ['a','b','c','d']
print (user_list.index('a'))

#输出
0

 

7、pop，删除并获取元素-索引

pop:pop根据索引进行删除

remove： remove根据元素进行删除

例子：

user_list = ['a','b','c','d']
v = user_list.pop(1)  #根据索引进行删除
print (user_list)

#输出
['a', 'c', 'd']

user_list.remove('a')  #根据元素值进行删除
print (user_list)

#输出

['c', 'd']

 

8、reverse，反转

例子：

user_list = ['a','b','c','d']
user_list.reverse()
print (user_list)


#输出
['d', 'c', 'b', 'a']


#第二种方法，切片
print (user_list[::-1])

#输出
['a', 'b', 'c', 'd']

9、sort，排序

例子：

num = [1,3,4,5,6]
num.sort()   #从大到小
print (num)

#输出
[1, 3, 4, 5, 6]

num.sort(reverse=True)  #从小到大
print (num)
#输出

[6, 5, 4, 3, 1]

 

 

10、额外功能

user_list = ['apple','pen','cat','tom','mic','lili']
user_list[0] #根据索引查值
user_list[1:5:2] #切片+步长
del user_list[3] #根据索引删除
for i in user_list: #循环列表
    print(i)
user_list[1] = 'happy' #根据索引赋值
user_list = ['apple','pen','cat','tom',['mic,'test''],'lili' #列表嵌套列表

 八、数据基本类型-tuple(元组)

　　元组的特性：属于不可变类型，不可被修改的列表

      *****元祖中套列表，字典，列表和字典是可变类型，可以被改变

      *****元祖最后要加一个逗号，避免元组里只有一个元素，被转换成字符串

1、元组计数count

例子：

user_tuple = ('a','b','c')
print (user_tuple.count('a'))

#输出
1

2、index获取索引位置

例子：

user_tuple = ('a','b','c')
print (user_tuple.index('b'))

#输出
1

3、tuple额外功能

list1 = [1,2,3,4,5]

tuple1 = tuple(list1)

print (tuple1)

#输出
(1, 2, 3, 4, 5)

for i in tuple1:
    print(i)

v = tuple1[0]  #查询

v = tuple1[0:2]  #分片
print(v)

user_tuple = tuple1
user_tuple[0] = 123   #错误方法
user_tuple[3] = [11,22,33] #错误方法
user_tuple[3][1] = '99'
print(user_tuple)

****** 元组最后，加逗号 ******
li = ('alex',)
print(li)

 

 

九、数据基本类型-dict(字典)

　　字典属于可变类型，key-value结构

 　  字典可嵌套，字典的key必须是不可变类型

1、clear清空

dic = {'k1':'v1','k2':'v2'}
dic.clear()
print(dic)


#输出 
{}

 

2、浅copy

dic = {'k1':'v1','k2':'v2'}
v = dic.copy()
print(v)


#输出
{'k1':'v1','k2':'v2'}

3、get,根据key值获取指定的value，不存在报错

dic = {'name':'seven','age':19}
v = dic.get('name')
print (v)

#输出

seven

 

4、pop删除

dic = {'name':'seven','age':19}
dic.pop('name')
print (dic)

#输出

{'age': 19}

 

5、popitem，随机获得键值对，并获取到删除的键值

dic = {'name':'seven','age':19}
dic.popitem()
print (dic)

#输出
不固定 --> {'name': 'seven'} / {'age': 19}

 

6、setdefault,增加kv,如果存在不增加，也不替换更新

dic = {'name':'seven','age':19}
dic.setdefault('page',18)
print (dic)

#输出
{'page': 18, 'age': 19, 'name': 'seven'}


dic = {'name':'seven','age':19}
dic.setdefault('name','dr')
print (dic)

#输出
{'age': 19, 'name': 'seven'}

 

7、update,批量增加或者修改

dic = {'name':'seven','age':19}
dic.update({'sex':'mid','page':18})
print (dic)


#输出
{'name': 'seven', 'age': 19, 'page': 18, 'sex': 'mid'}

8、fromkeys

　　函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。dic = dict.fromkeys(['k1','k2','k3'],123)

print(dic)
dic = dict.fromkeys(['k1','k2','k3'],123)
dic['k1'] = 'guest'
print(dic)
#输出

{'k1': 123, 'k3': 123, 'k2': 123}
{'k1': 'guest', 'k3': 123, 'k2': 123}

 

 

十、数据基本类型-集合

　　集合是不可重复的列表，可变类型

1、difference

s1 = {"alex",'eric','tony','happy','lili'}
s2 = {"alex",'eric','tony','anni'}
#1.s1中存在，s2中不存在
v = s1.difference(s2)
print(v)

#输出
{'lili', 'happy'}

2、difference_update

s1 = {"alex",'eric','tony','happy','lili'}
s2 = {"alex",'eric','tony','anni'}
#s1中存在，s2中不存在，然后对s1清空，然后在重新复制
s1.difference_update(s2)
print(s1)

#输出
{'happy', 'lili'}

 

3、difference_update

#s2中不存在，s1中存在，s1中不存在，s2中存在
s1 = {"alex",'eric','tony','happy','lili'}
s2 = {"alex",'eric','tony','anni'}
v = s1.symmetric_difference(s2)
print(v)

#输出
{'lili', 'happy', 'anni'}

 

4、intersection交集

s1 = {"alex",'eric','tony','happy','lili'}
s2 = {"alex",'eric','tony','anni'}
v = s1.intersection(s2)
print(v)
#输出
{'tony', 'alex', 'eric'}

 

5、union并集

s1 = {"alex",'eric','tony','happy','lili'}
s2 = {"alex",'eric','tony','anni'}
v = s1.union(s2)
print(v)

#输出
{'lili', 'alex', 'tony', 'anni', 'eric', 'happy'}

 

6、discard移除

s1 = {"alex",'eric','tony','happy','lili'}
s1.discard('alex')
print(s1)
#输出
{'tony', 'lili', 'eric', 'happy'}

 

7、update更新

s1 = {"alex",'eric','tony','happy','lili'}
s1.update({'alex','123123','fff'})
print(s1)
#输出
{'lili', 'alex', '123123', 'eric', 'fff', 'tony', 'happy'}

 

 

十一、range

python2.* : range会立刻生成数字，加载到内存中

python2.* : xrange 生成一个迭代值，只有循环迭代的时候，才会一一调用

python3.* ：range会生成一个迭代值，只有循环迭代的时候，才会一一调用

for i in range(10):
    print(i)

#输出
0
1
2
3
4
5
6
7
8
9

for i in range(1,11,2): #输出奇数
     print(i)

for i in range(10,0,-1): #从大到小输出
     print(i)

 

十二、enumerate

#enumerate额外生成一列有序的数字
li = ['pie','pig','apple']
for i,v in enumerate(li,1):
    print(i,v)

#输出
1 pie
2 pig
3 apple