day02_20190106 基础数据类型编码运算符

太白的学习目录 https://www.cnblogs.com/jin-xin/p/9076242.html

编码上

计算机要想工作必须通电,也就是说‘电’驱使计算机干活,而‘电’的特性，就是高低电平(高低平即二进制数1,低电平即二进制数0),也就是说计算机只认识数字(010101).如果我们想保存数据,首先得将我们的数据进行一些处理，最终得转换成010101才能让计算机识别。

　所以必须经过一个过程：

　　字符（str）--------（编码过程）------->数字（bytes 二进制字符串类似str）

　　这个过程实际就是一个字符如何对应一个特定数字的标准，这个标准称之为字符编码。

1、ASCII：最初版本的编码方式：（支持对英文字母、数字、特殊字符等进行编码）

ASCII码是上个世纪最流行的编码体系之一，至少在西方是这样。下图显示了ASCII码中编码单元是怎么映射到字符上的。

最开始：
0000 0001 256种可能。 0000 0001 8位 = 1个字节（bytes）。
s1 = 'hello1' 6个字节，一个字节表示一个字符。
h-------->01101000 e-------->01100101 l -------->01101100 l -------->01101100 o -------->01101111 1 --------> 00110001

2、GBK：为了满足中文，中国人定制了GBK

GBK:2Bytes代表一个字符；为了满足其他国家，各个国家纷纷定制了自己的编码。日本把日文编到Shift_JIS里，韩国把韩文编到Euc-kr里

只包含：本国语言（中文汉字、中文特殊字符等）和对ASCII的映射（支持对英文字母、数字、特殊字符等进行编码）

GBK是GB2313的升级版支持21000+个汉字

3、unicode：万国码。把全世界所有的文字都记录起来。（2~4个字节，已经收录了136690个字符，还在一直不断扩张中。。。）
起初：一个字符两个字节（只能表示256*256个）
h： 01101000 01101000 中：01101000 01101000
不够用升级：一个字符四个字节
h: 01101000 01101000 01101000 01101000 中: 01111000 01101000 01101000 01101000
浪费空间，浪费流量

Unicode包含了跟全球所有国家编码的映射关系，解决了字符与二进制（bytes）的对应关系、但是使用Unicode表示一个字符，太浪费空间。例如利用Unicode表示“Python”需要12个字节才能表示，比原来Ascll表示增加了1倍

由于计算机的内存比较大。并且字符串在内容中表示时也不会特别大，所以内容可以使用unicode来处理，但是存储和网络传输时一般数据都会非常多，那么增加1倍将是无法容忍的！！！

4、utf-8: 最少用8位一个字节表示一个字符。

为了解决存储和网络传输的问题，出现了 Unicode Transformation Format，学术名：UTF
h: 01101000 　　ASCII 英文字符：1个字节表示
Tú.: 01101000 01101000 　　欧洲语系：一个字符2个字节表示
中: 01101000 01101100 01101000 东亚：一个字符用3个字节表示。
'中国 I LOVE YOU' utf-8的编码方式： 14个字节

单位转化：
8bit == 1bytes （字节） 1024bytes == 1KB 1024KB == 1MB 1024MB == 1GB 1024GB == 1TB

Python3文件存储和传输时默认是UTF-8编码方式的；加载进入内存里时Python3解释器把utf-8文件默认解码（decode）成Unicode ；编写Python3文件时默认编码是Unicode（内存中），存储的时候编码成（encode）utf-8文件；只有Python3是这样的！！！

# 例子一：在python3中有两种字符串类型str和bytes 转换 :str ------编码（Unicode或者utf-8）---->bytes

s1 = '中国' # 当程序执行时，'中国'会被以unicode形式保存新的内存空间中,（加载到内存 默认已经Unicode的编码了 已经变成bytes了）

# unicode ---> utf-8

#s指向的是unicode，因而可以编码成任意格式，都不会报encode错误

b1 = s1.encode('utf-8') # 编码

print(b1,type(b1))

# utf-8 ----> unicode

s2 = b1.decode('utf-8') # 解码

print(s2,type(s2))  #Python2里面的Unicode类型变成str了

例子二：

s1 = '中国'

b1 = s1.encode('gbk') # gbk编码

print(b1)

# gbk----> unicode

s2 = b1.decode('gbk') # 解码

print(s2)

例子三：

# gbk ---> utf-8

b1 = b'\xd6\xd0\xb9\xfa'

s1 = b1.decode('gbk')  # unicode

b2 = s1.encode('utf-8')

print(b2)

1， 不同密码本（编码方式 GBK、UTF-8等等）之间不能互相识别。报错，乱码。

2， 数据的存储或者网络传输不能用unicode的密码本进行编码。

python3x 环境：

str类型内部编码方式为Unicode。

所以：str类数据不能直接存储硬盘，或者网络传输。

例子：str: 操作方法  bytes: 拥有和str相同的操作方式  str与bytes是相似的类型

 str1 = 'barry'

 print(str1.upper())

#bytes

b1 = b'barry'

print(b1.upper())

str类型内部编码方式为Unicode。

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

英文：

str:

表现形式：'alex'

内部编码：unicode

bytes:

表现形式：b'alex'

内部编码：非unicode

中：

str:

表现形式：'alex'

内部编码：unicode

bytes:

表现形式：b'\xe4\xb8\xad\xe5\x9b\xbd'

内部编码：非unicode

编码下

四、数据类型的转换
bool <---> int
str <---> int
s1 = '100' 全部由数字组成的str ---> int
int(s1)
str(100)
str <---> bool 非空即True '' 空即False

五、基础数据类型 str

1、字符串的索引与切片。

索引即下标，就是字符串组成的元素从第一个开始，初始索引为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]) #反向加步长

2、字符串常用方法。对字符串进行的任何操作都会形成一个新字符串，与原字符串无关。

1. 英文字母大小写切换（upper()全大写 lower() 全小写）

username = input('请输入用户名')

password = input('请输入密码')

code = 'afREd'.upper()

your_code = input('请输入验证码：').upper()

if code == your_code:

    if username == 'barry' and password == '':

        print('登录成功')

else:

    print('验证码错误')

验证码的例子

2. strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符、制表符）或字符序列。（ lstrip()只去掉左边的、 rstrip()只去掉右边的）

注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。

strip()方法语法：str.strip([chars]);
chars -- 移除字符串头尾指定的字符序列。
返回移除字符串头尾指定的字符生成的新字符串。

s1 = ' \talex\n'

s2 = 'ewareelexqw'

s3 = '\talex   '

s4 = 'alex\talex'

s5 = s1.strip()

s6 = s2.strip('qwe')  # 相当于字符串两边  移除列表中的['qwe','qw','we','q','w','e']

s7 = s3.strip()

s8 = s4.strip()

print(s5)  #alex

print(s6)  #areelex

print(s7)  #alex

print(s8)  #alex    alex

username = input('请输入用户名').strip()

password = input('请输入密码').strip()

if username == 'barry' and password == '':

    print('登录成功')

3. find和index方法

find 通过元素找索引，找到用第一个则返回，找不到返回-1
index 通过元素找索引，找到用第一个则返回，找不到则报错

s1 = '周末2期python期'

# i = s1.find('w')

i = s1.find('期',4,)  #从索引为4的下标开始找

# i = s1.index('w')

print(i)

# ret6 = a4.find("fjdk",1,6)
# print(ret6) # 返回的找到的元素的索引，如果找不到返回-1

# ret61 = a4.index("fjdk",4,6)
# print(ret61) # 返回的找到的元素的索引，找不到报错。

4. split() 默认(可指定分隔符)以空格为分割，返回一个列表。（ str ----> list 可以将字符串变为列表）

s1 = 'alex wusir 太白 日天'

l1 = s1.split()

print(l1)  #['alex', 'wusir', '太白', '日天']

s12 = 'alex:wusir:太白:日天'

l2 = s12.split(':')

print(l2)   #['alex', 'wusir', '太白', '日天']

# 指定分隔次数

s11 = ':alex:wusir:太白:日天'

l3 = s11.split(':', 2)

print(l3)  #['', 'alex', 'wusir:太白:日天']

5. splitlines() 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

方法语法：str.splitlines([keepends])
参数说明： keepends - - 在输出结果里是否保留换行符('\r', '\r\n', \n')，默认为 False，不包含换行符，如果为 True，则保留换行符。
返回值：返回一个包含各行作为元素的列表。

# !/usr/bin/python

str1 = 'ab c\n\nde fg\rkl\r\n'

print(str1.splitlines()) #['ab c', '', 'de fg', 'kl']

str2 = 'ab c\n\nde fg\rkl\r\n'

print(str2.splitlines(True)) #['ab c\n', '\n', 'de fg\r', 'kl\r\n']

6. join 合并列表里的字符串成为一个大字符串

l1 = ['alex', 'wusir', '太白', '日天']

# s2 = '_'.join(l1)

s2 = '*'.join(l1)

# 前提条件：此列表必须全部是有字符串元素组成

# s2 = ''.join(l1)

print(s2)

7. replace 默认全部替换也可以设置替换次数

s1 = 'python深圳分校 深圳是一个很美丽的城市，我爱深圳'

# s2 = s1.replace('深圳', '北京')

s2 = s1.replace('深圳', '北京', 1)  #只替换一次

print(s2)

8. format

# # 第一种

# msg = '我叫{} 今年{} 性别{}'.format('太白', '18', '男')

# print(msg)

# # 第二种

# msg = '我叫{0} 今年{1} 性别{2}，我依然叫{0}'.format('太白', '18', '男')

# print(msg)

# # 第三种

msg = '我叫{name} 今年{age} 性别{sex}'.format(name='太白', sex='男',age='',)

print(msg)

9. count 计算某个元素出现的次数

s1 = 'barryafdfdafdaaa'

i = s1.count('a')

print(i)

# ret3 = a1.count("a",0,4) # 可切片
# print(ret3)

10. is 系列

name = 'taibai123'

# print(name.isalnum()) #字符串由字母或数字组成

# print(name.isalpha()) #字符串只由字母组成

# print(name.isdigit()) #字符串只由数字组成

11. startswith 判断以...为开始 endswith 判断以...为结尾

s1 = '太白barry'

print(s1.startswith("太"))

print(s1.startswith("b",2,5))  #下表为2的元素开始 至  下标为5的元素 为止  顾头不顾尾

print(s1.startswith("ba",2,5))

12. len 内置函数

# s1 = 'fjdsklfsjafldsfjskladfjsladfjldksa'

# print(len(s1))

s1 = 'python2期'

# while

count = 0

while count < len(s1):

    print(s1[count])

    count += 1

# for 循环

# for 变量 in iterable:

#     pass

for i in s1:

    print(i,type(i))

for i in s1:

    print(i + 'sb')

13 .其它方法

name = 'abC'

#captalize,swapcase,title

print(name.capitalize()) #首字母大写  Abc

print(name.swapcase()) #大小写翻转  ABc

msg='taibai say hi'

print(msg.title()) #每个单词的首字母大写  Taibai Say Hi

# 内同居中，总长度，空白处填充

a1 = 'haha'

ret2 = a1.center(20,"*")

print(ret2)  #********haha********

六、基础数据类型 list(tuple)

str数据类型这么强大为什么要引入list？
如：str类型：'alex123'
1,存储少量数据。 2，数据类型单一。

容器类的数据类型：基础数据类型之一：list。
l1 = [1,'alex',True,[1,2,3], ().....]
列表可以存储大量的数据，列表是有顺序的。列表有索引，切片，切片（步长）
当你需要大量数据进行存储，并且是按照一定顺序，考虑到list

# 索引，切片。顾首不顾尾：首从索引0开始，尾从索引-1开始。

l1 = [100, 'alex', True, [1,2,3]]

print(l1[0],type(l1[0])) #100 <class 'int'>

print(l1[-2]) #True

print(l1[:3]) #[100, 'alex', True]

列表的常用操作方法.增删改查其他操作

l1 = ['alex', 'wusir', '太白金星','日天', '女神']

# 1、append 追加

ret01 = l1.append(666)

print(ret01) #None

print(l1) #['alex', 'wusir', '太白金星', '日天', '女神', 666]

# 2、insert插入 insert(索引，元素)

ret02=l1.insert(1,'日天')

print(ret02)#None

print(l1)#['alex', '日天', 'wusir', '太白金星', '日天', '女神', 666]

# 3、extend 迭代着追加

l1.extend('abc')

ret03=l1.extend([1,2,3])

print(ret03)#None

print(l1) #['alex', '日天', 'wusir', '太白金星', '日天', '女神', 666, 'a', 'b', 'c', 1, 2, 3]

1.增

l1 = ['alex', 'wusir', '太白金星','日天', '女神']

# 1、pop 按照索引删除 有返回值

# ret = l1.pop(-1)

# print(ret) #女神  并返回该索引值

# 2、remove 按照元素删除

# ret1 = l1.remove('alex')

# print(l1,ret1) #['wusir', '太白金星', '日天', '女神'] None

# 3、clear

# l1.clear()

# print(l1) #[]

# 4、del

del l1[0] # 按照索引删除

print(l1)

del l1[:2] # 按照切片删除

print(l1)

del l1

# print(l1)

2. 删

l1 = ['alex', 'wusir', '太白金星','日天', '女神']

# 按照索引改值

l1[1] = 'sb'

print(l1)  #['alex', 'sb', '太白金星', '日天', '女神']

# 按照切片改值

l1[:3] = 'haxi'

print(l1)  #['h', 'a', 'x', 'i', '日天', '女神']

3.改

# 四、查：可以索引切片 for循环

l1 = ['alex', 'wusir', '太白金星','日天', '女神']

for i in l1:

    print(i)

4.查

其他操作方法

l1 = ['alex', 'wusir', '太白金星','日天', '女神']

1、元素个数

print(len(l1))

2、count 次数

ret = l1.count('太白金星')

print(ret)

3、index 通过元素找索引，找不到报错

# ret = l1.index('日天1')

# print(ret)

4、sort与reverse

l2 = [5, 6, 4, 0, 9, 1, 7, 8]

l2.sort() # 从小到大

l2.sort(reverse=True) # 从大到小

l2.reverse() # 翻转

print(l2)

列表的嵌套

l1 = [1, 2, 'taibai', [1, 'alex', 3, ]]

'''

1, 将l1中的'taibai'变成大写并放回原处。

2，给小列表[1,'alex',3,]追加一个元素,'老男孩教育'。

3，将列表中的'alex'通过字符串拼接的方式在列表中变成'alexsb'。

'''

l1[2] = l1[2].upper()

l1[-1].append('老男孩教育')

l1[3][1] = l1[3][1] + 'sb'

print(l1)

# range 可以视为一个可控的数字范围的列表，多于for循环结合。

# for i in range(1,10): # [1,2,3,4,...9]

#　　 print(i)

# for i in range(20): # [0,1,2,3,4,...19]

# 　　 print(i)

for i in range(0,10,2):

    print(i)

print(range(10))

for i in range(10, 1, -1):

    print(i)

# range 打印列表的索引

l1 = ['alex', 'wusir', '太白金星','日天', '女神']

for index in range(len(l1)):

    print(index)

range 可以视为一个可控的数字范围的列表，多于for循环结合

元组：基础数据类型之一：tuple

# 存储数据，重要的数据。元组不可以增删改，可以查询，元组的子集可以修改。元组也有索引切片。

tu1 = (100, True, [1,2,3])

print(tu1[0])

for i in tu1:

    print(i)

tu1[-1].append(666)

print(tu1)  #(100, True, [1, 2, 3, 666])

七、基础数据类型 dict

有了列表，why还要使用字典？
1,列表的数据量越大，查询速度越慢。2，列表存储的数据没有什么关联性。

基础数据类型之dict eg：dic = {'name': 'barry'} 字典是以键值对的形式存储的。

字典的键key：必须是不可变得数据类型：int str
字典的值：任意数据类型变量，对象。
字典可以存储大量的数据，而且字典的查询速度非常快。
字典的key 唯一的不重复的。
字典 3.5之前是无序的，字典在3.5之后是有序的初始化时的顺序。
构建数据类型：大量的关系型数据时，要到字典。

数据类型的划分：
可变的（不可哈希）数据类型：list dict set
不可变（可哈希）的数据类型：tuple str int bool

# 1、增：有则修改，无则增加

dic = {'name': 'alex', 'age': 46, 'sex': 'laddyboy'}

dic['high'] = 175

dic['name'] = '日天'

# 有则不变，无则增加

dic.setdefault('weight',200)

dic.setdefault('age',73)

print(dic)

# 2、删除： （pop、clear、del）

dic = {'name': 'alex', 'age': 46, 'sex': 'laddyboy'}

ret = dic.pop('name')#按照key删除键值对,有返回值  返回值为删除键的值

print(ret,dic)#alex {'age': 46, 'sex': 'laddyboy'}

dic.clear()#清空该字典的所有值 不删字典

print(dic) #{}

#del dic  #删除整个字典

# del dic['name'] #删除某个值

# 3、改

dic = {"name":"jin","age":18,"sex":"male"}

dic['name'] = '日天' #修改单个值

dic2 = {"name":"alex","weight":75}

dic2.update(dic) # 将dic的键值对覆盖添加到dic2中，dic不变。

print(dic,dic2)#{'name': '日天', 'age': 18, 'sex': 'male'} {'name': '日天', 'weight': 75, 'age': 18, 'sex': 'male'}

# 4、查

dic = {'name': 'alex', 'age': 46, 'sex': 'laddyboy'}

print(dic['name'])

# print(dic['name1'])  #KeyError: 'name1'

ret01 = dic.get('name1')  #None

ret02 = dic.get('name1', '没有此键')

ret03 = dic.get('name')

print(ret01,ret02,ret03)  #None 没有此键 alex

字典的增删改查

5、其他方法：

dic = {'name': 'alex', 'age': 46, 'sex': 'laddyboy'}

for key in dic:

    print(key,dic[key])

    #name alex

    #age 46

    #sex laddyboy

# dic.keys() dic.values() dic.items()

print(dic.keys(),type(dic.keys()))  #dict_keys(['name', 'age', 'sex']) <class 'dict_keys'>

for key in dic.keys():

    print(key,type(key))

for value in dic.values():

    print(value)

print(dic.items()) # dict_items([('name', 'alex'), ('age', 46), ('sex', 'laddyboy')])

for k,v in dic.items():

    print(k,v)

print(list(dic.items()))  #[('name', 'alex'), ('age', 46), ('sex', 'laddyboy')]

6、嵌套

dic = {

'name_list': ['张三', '李四', 'BARRY'],

1:{'name':'taibai', 'age': 18},

'barry': {}

}

# 1，给列表追加一个值：'王五'

dic['name_list'].append('王五')

print(dic)

# 2，将BARRY 变成全部小写

print(dic['name_list'][-1].lower())

dic['name_list'][-1] = dic['name_list'][-1].lower()

print(dic)

# 3，给{'name':'taibai', 'age': 18} 增加一个键值对 sex: 男。

print(dic[1])

dic[1]['sex'] = '男'

print(dic)

八、基础数据类型的补充（汇总）。
int str bool list tuple dict
# 数据类型的转换。

分别赋值

a, b = 1, 4

print(a,b) #1 4

c, d = (1,4)

print(c,d) #1 4

e, f = [[1,2,3],'alex']

print(e,f)#[1, 2, 3] alex

list 列表的一个坑

l1 = [11, 22, 33, 44, 55]

# 将列表中索引为奇数位的元素删除

# 正常思路（错误示范）：

for index in range(len(l1)):

　　if index % 2 == 1:

　　　　del l1[index]

print(l1)

# 方法一：

del l1[1::2]

print(l1)

# 方法二：

# 倒叙删除

for index in range(len(l1)-1,-1,-1):   # index -= 1

　　if index % 2 == 1:

　　　　l1.pop(index)

print(l1)

# 总结：对于列表来说，你在循环一个列表时，不要改变列表的大小，会影响你的最终结果

字典的一个坑

dic = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'name': '太白'}

# 将字典的键中含有k元素的所有键值对删除

for key in dic:

　　if 'k' in key:

　　　　dic.pop(key)

print(dic)

# 满足条件的key添加到一个新列表中，循环列表删除相应的键值对。

l1 = []

for key in dic:

　　if 'k' in key:

　　　　l1.append(key)

print(l1)

for i in l1:

　　dic.pop(i)

print(dic)

1， 不同密码本（编码方式 GBK、UTF-8等等）之间不能互相识别。报错，乱码。

2， 数据的存储或者网络传输不能用unicode的密码本进行编码。

python3x 环境：

str类型内部编码方式为Unicode。

所以：str类数据不能直接存储硬盘，或者网络传输。

例子：str: 操作方法  bytes: 拥有和str相同的操作方式  str与bytes是相似的类型

 str1 = 'barry'

 print(str1.upper())

#bytes

b1 = b'barry'

print(b1.upper())

str类型内部编码方式为Unicode。

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

英文：

str:

表现形式：'alex'

内部编码：unicode

bytes:

表现形式：b'alex'

内部编码：非unicode

中：

str:

表现形式：'alex'

内部编码：unicode

bytes:

表现形式：b'\xe4\xb8\xad\xe5\x9b\xbd'

内部编码：非unicode

编码下

巴特西

day02_20190106 基础数据类型编码运算符

1、字符串的索引与切片。

2、字符串常用方法。对字符串进行的任何操作都会形成一个新字符串，与原字符串无关。

1. 英文字母大小写切换（upper()全大写 lower() 全小写）

2. strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符、制表符）或字符序列。（ lstrip()只去掉左边的、 rstrip()只去掉右边的）

3. find和index方法

4. split() 默认(可指定分隔符)以空格为分割，返回一个列表。（ str ----> list 可以将字符串变为列表）

5. splitlines() 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

6. join 合并列表里的字符串成为一个大字符串

7. replace 默认全部替换也可以设置替换次数

8. format

9. count 计算某个元素出现的次数

10. is 系列

11. startswith 判断以...为开始 endswith 判断以...为结尾

12. len 内置函数

13 .其它方法

元组：基础数据类型之一：tuple

最新文章

热门文章

巴特西

day02_20190106 基础数据类型 编码 运算符

1、字符串的索引与切片。

2、字符串常用方法。对字符串进行的任何操作都会形成一个新字符串，与原字符串无关。

1. 英文字母大小写切换 （upper()全大写 lower() 全小写 ）

2. strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符、制表符）或字符序列。 （ lstrip()只去掉左边的、 rstrip()只去掉右边的 ）

3. find和index方法

4. split() 默认(可指定分隔符)以空格为分割，返回一个列表。（ str ----> list 可以将字符串变为列表）

5. splitlines() 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

6. join 合并列表里的字符串成为一个大字符串

7. replace 默认全部替换 也可以设置替换次数

8. format

9. count 计算某个元素出现的次数

10. is 系列

11. startswith 判断以...为开始 endswith 判断以...为结尾

12. len 内置函数

13 .其它方法

元组： 基础数据类型之一：tuple

最新文章

热门文章

day02_20190106 基础数据类型编码运算符

1. 英文字母大小写切换（upper()全大写 lower() 全小写）

2. strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符、制表符）或字符序列。（ lstrip()只去掉左边的、 rstrip()只去掉右边的）

7. replace 默认全部替换也可以设置替换次数

元组：基础数据类型之一：tuple