day02_20170507_python-基础（二）

一、进制

　　1、硬盘上保存的数据是以二进制保存的，以0和1的形式。

　　2、保存文件是以什么编码格式（utf-8/gbk）保存的,读取的时候，首先读到的是01，在转换成对应编码的汉字。

　　3、用户所看到的：

　　　　-转换完成的字符串

　　　　-以十六进制展示的0101

小例子：首先新建一个log文件,随便输入汉字，然后再以汉字的形式读出：

　　log.txt

今天天气不错a!!!

　　python.py 

#!/usr/bin/python
# -*- coding:utf-8 -*-
f = open('log','r',encoding='utf-8')
data = f.read()
print(data)
f.close()
输出的结果：
今天天气不错a!!!

　　如果我不想以汉字格式读出，只想以01的形式读出：

#!/usr/bin/python
# -*- coding:utf-8 -*-
f = open('log','rb')
data = f.read()
print(data)
f.close()
输出的结果：
b'sdfdfdfafdsfadxe5x8fx91xe5x8fx91xe9x80x81xe5x88xb0'
注意：
最终输出的结果是以十六进制展示出来了。其中的b表示字节。

二、基本数据类型

　　类与对象：这么一类保存功能的地方，统称为“类”。如：str、 list、int、dict

                   调用这些功能的东西称为对象，更具体的为：类str的对象，类int的对象，类list的对象，类dict的对象。

　　在pycharm中如何查看某一个类下面有哪些功能呢？拿str举例，如下图：

A、字符串 str

1、capitalize 字符串首字母大写（name变量自身不变，会生成一个新的值v）

name = 'alex' # str类的对象
v = name.capitalize() # 自动找到name关联的str类，执行其中的capitalize技能
print(name)
print(v)
输出的结果：
alex
Alex

2、casefold 将所有大写变小写

name = 'AleX'
v = name.casefold() # 更牛逼，可以识别德语...
print(name)
print(v)
输出结果：
AleX
alex

3、lower 将所有大写变小写

name = 'AleX'
v = name.lower()
print(v)
输出结果：
alex

　　注意：casefold与lower的区别：casefold不仅可以识别英文，还可以识别德语等，比如β在德语里面变成小写是两个ss，lower无法完成这个功能。

4、center 文本居中

　# 参数1: 表示总长度

　# 参数2：空白处填充的字符（长度为1）

name = 'alex'
v = name.center(20)
print(v)
v = name.center(20,'行')
print(v) 
输出结果：
 　　　　 alex 
行行行行行行行行alex行行行行行行行行　

5、count 表示传入值在字符串中出现的次数

      #参数1：要查找的值（子序列）

　　#参数2：其实位置（索引）

　　#参数3：结束位置（索引）

name = "alexasdfdsafsdfasdfaaaaaaaa"
v = name.count('a')
print(v)
v = name.count('df')
print(v)
输出结果：
12
3

　　

name = "alexasdfdsafsdfasdfaaaaaaaa"
v = name.count('df',12)
print(v)
v = name.count('df',0,15)
print(v)
输出结果：
2
2

6、endswith 判断字符串是否以xx结尾

name = 'alex'
v1 = name.endswith('ex')
print(v1)
输出结果：
True

7、startswith 判断字符串是否以xx开头

name = 'alex'
v2 = name.startswith('al')
print(v2)
输出结果：
True

8、encode欠　　

9、expandtabs 找到制表符 ,进行替换（包含前面的值） PS:

name = "al	e	x
alex	uu	kkk"
v = name.expandtabs(20)
print(v)
输出结果：
al                  e                   x
alex                uu                  kkk

10、find 找到指定子序列的索引位置：不存在返回-1

name = 'alex'
v = name.find('o')
print(v)

　index也是找到指定子序列的索引位置，但是不存在时候报错：

name = 'alex'
v = name.index('o')
print(v)
输出结果：
ValueError: substring not found

11、format、format_map字符串格式化

tpl = "我是:%s;年龄:%s;性别:%s"

tpl = "我是:{0};年龄:{1};性别:{2}"
v = tpl.format("李杰",19,'都行')
print(v)

tpl = "我是:{name};年龄:{age};性别:{gender}"
v = tpl.format(name='李杰',age=19,gender='随意')
print(v)

tpl = "我是:{name};年龄:{age};性别:{gender}"
v = tpl.format_map({'name':"李杰",'age':19,'gender':'中'})
print(v)
输出结果：
我是:李杰;年龄:19;性别:都行
我是:李杰;年龄:19;性别:随意
我是:李杰;年龄:19;性别:中

12、isalnum、isalpha 判断是否是数字、汉字.

name  = 'alex8汉子'
v = name.isalnum() # 字,数字
print(v) # True
v2 = name.isalpha()#
print(v2)# False

13、isdecimal、isdigit、isnumeric判断是否是数字

num='②'
v1= num.isdecimal() #'123'，只能判断阿拉伯的，用的最多的是这个，因为他可以通过int转换
v2=num.isdigit() #'123','②' 阿拉伯和②de
v3=num.isnumeric() #'123'，'二','②' 中文的也可以判断
print(v1,v2,v3)
输出结果：
False True True

14、isidentifier 是否是表示符

n = 'name'
v = n.isidentifier()
print(v)
输出结果：
True

15、islower、isupper 是否全部是小写（或大写）

name = "ALEX"
v = name.islower()
print(v)
v = name.isupper()
print(v)
输出结果：
False
True

16、upper、lower全部变大写（小写）------什么时候用呢？输入验证码，输入之后统一变成大写

name = 'alex'
v = name.upper()  # lower()
print(v)
输出结果：
ALEX

17、isprintable 判断字符串是否包含隐含的xx

name = "钓鱼要钓刀鱼，
刀鱼要到岛上钓"
v = name.isprintable()
print(v)
输出结果：
False

18、isspace 是否全部是空格

name = '    '
v = name.isspace()
print(v)
输出结果：
True

19、join. 元素拼接（元素是字符串或者字符），五星级应用，以后经常用

name = 'alex'

v = "_".join(name)  #内部循环这个字符串的每一个字符，比如第一个字符之后发现还有字符，那就在第一个字符后面加上_
print(v)

name_list = ['海峰','杠娘','李杰','李泉']#这个应该是字符串，如果是数字，就不行了
v = "搞".join(name_list)
print(v)
输出结果：
a_l_e_x
海峰搞杠娘搞李杰搞李泉

20、center,rjust,ljust 左右填充

name = 'alex'
v = name.rjust(20,'*')
print(v)
输出结果：
****************alex

21、maketrans、translate对应关系 + 翻译

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

name = "akpsojfasdufasdlkfj8ausdfakjsdfl;kjer09asdf"
v = name.translate(m)
print(v)
输出结果：
1kps4jf1sd5f1sdlkfj815sdf1kjsdfl;kj2r091sdf

22、partition 分割，保留分割的元素

content = "李泉SB刘康SB刘一"
v = content.partition('SB') # partition
print(v)
输出结果：
('李泉', 'SB', '刘康SB刘一')

#什么情景用呢？计算器：1*3+9-7*77  按照符号进行分割

rpartition从右找进行分割

content = "李泉SB刘康SB刘义"
v = content.rpartition('SB')
print(v)
输出结果：
('李泉SB刘康', 'SB', '刘义')

23、replace 替换

content = "李泉SB刘康SB刘浩SB刘一"
v = content.replace('SB','Love')
print(v)
v = content.replace('SB','Love',1)
print(v)
输出结果：
李泉Love刘康Love刘浩Love刘一
李泉Love刘康SB刘浩SB刘一

24、strip 移除空白 换行 以及制表符 ，还可以自己定义

name = 'alex	'
v = name.strip() # 空白,
,	
print(v)
输出结果：
alex

25、swapcase 大小写转换

name = "Alex"
v = name.swapcase()
print(v)
输出结果：
aLEX

26、zfill 填充0

name = "alex"
v = name.zfill(20)
print(v)
输出结果：
0000000000000000alex

27、__add__带双下划綫的是有特殊意义的

v1 = 'alex'
v2 = 'eric'
v = v1 + v2 #执行v1的__add__功能
print(v)
输出结果：
alexeric

28、额外功能

name = "alex"
name[0]#取索引
name[0:3]#取前三个字符
name[0:3:2]#步长取值
len(name)#取长度
#for循环，每个元素是字符

29、补充知识

补充encode  一个字符串也可以转换成字节类型，以后文件或者网络传输的时候会用到

# **** 转换成字节 ****
name = "李杰"
v1 = name.encode(encoding='utf-8') # 字节类型
print(v1)
v2 = name.encode(encoding='gbk') # 字节类型
print(v2)
输出结果：
b'xe6x9dx8exe6x9dxb0'
b'xc0xeexbdxdc'

B、 整数 int

1、bit_length 用二进制表示有几位

age = 4 # 100
print(age.bit_length())#当前数字可以用二进制的最少位数来表示
输出结果：
3

2、to_byte(把当前类型转换成字节) 获取当前数据的字节表示

age = 15
v1 = age.to_bytes(10,byteorder='big')
v2 = age.to_bytes(10,byteorder='little')
print(v1)
print(v2)
#byteorder有两个值分别是 big和little。不能是其他的值了
# 00000000 00001111 -> 15
输出结果：
b'x00x00x00x00x00x00x00x00x00x0f'
b'x0fx00x00x00x00x00x00x00x00x00'

C、bool 布尔值　

# v = 0 # 1，-1
# v = ""
# v = []
# -->空内容：False

D、list 列表　　

#注意：定义变量的时候不要用 int = xx ;str='xxx'  list='xx' 因为这个变量名称都是有特殊意义的
#user_list = ['李泉','刘义','刘康','豆豆','小龙']#这样 user_list就不会和一些内置的东西重名了
#执行功能之后一般情况下就是列表本身发生变化

1、append 追加

user_list = ['李泉','刘一','刘康','豆豆','小龙'] # 可变类型
user_list.append('刘铭')
print(user_list)
输出结果：
['李泉', '刘一', '刘康', '豆豆', '小龙', '刘铭']

#ps：列表是一个可变类型，而字符串是一个不可变的类型，不可能修改他的值，除非你重新创建一个，然后以前的不用的就被垃圾回收掉

2、clear 清空

user_list = ['李泉','刘一','刘康','豆豆','小龙'] # 可变类型
user_list.clear()
print(user_list)
输出结果：
[]

3、copy 拷贝(浅拷贝)

user_list = ['李泉','刘一','刘康','豆豆','小龙'] # 可变类型
v = user_list.copy()
print(v)
print(user_list)
输出结果：
['李泉', '刘一', '刘康', '豆豆', '小龙']
['李泉', '刘一', '刘康', '豆豆', '小龙']

4、count 计数

user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙'] # 可变类型
v = user_list.count('李泉')
print(v)
输出结果：
2

5、extend 扩展原列表

user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙'] # 可变类型
user_list.extend(['郭少龙','郭少霞'])
print(user_list)
输出结果：
['李泉', '刘一', '李泉', '刘康', '豆豆', '小龙', '郭少龙', '郭少霞']

6、index 查找元素索引，没有就报错

user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙'] # 可变类型
v = user_list.index('李海')
print(v)
输出结果：
ValueError: '李海' is not in list

7、pop 删除并且获取元素 - 索引（根据索引进行删除）

user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙'] # 可变类型
v = user_list.pop(1)
print(v)
print(user_list)
输出结果：
刘一
['李泉', '李泉', '刘康', '豆豆', '小龙']

8、remove 删除 - （根据值进行删除）

user_list = ['李泉','刘一','李泉','刘康','豆豆','小龙'] # 可变类型
user_list.remove('刘一')
print(user_list)
输出结果：
['李泉', '李泉', '刘康', '豆豆', '小龙']

9、reverse 翻转

#v为none,证明修改的是本身，会把原来的列表进行翻转
user_list = ['李泉','刘义','刘康','豆豆','小龙','李泉']
v = user_list.reverse()
print(v)
print(user_list)
输出结果：
None
['李泉', '小龙', '豆豆', '刘康', '刘义', '李泉']

10、sort 排序

#v为none，表示给自个列表本身尽行了排序
nums = [11,22,33,44,55,3,3,9,88]
v = nums.sort()
print(v)
print(nums)
#如何从大到小呢
nums = [11,22,33,44,55,3,3,9,88]
nums.sort(reverse=True)
print(nums)
输出结果：
None
[3, 3, 9, 11, 22, 33, 44, 55, 88]
[88, 55, 44, 33, 22, 11, 9, 3, 3]

11、额外

user_list = ['李泉','刘义','刘康','豆豆','小龙','李泉']
user_list[0]
user_list[1:5:2]
del user_list[3]
for i in user_list:
    print(i)
user_list[1] = '江日天'#修改
user_list = ['李泉','刘义','刘康','豆豆','小龙','李泉',[1,3,4]]#嵌套

12、补充知识点

#删除某个区间的元素
li = ['李泉','刘义','刘康','豆豆','小龙','李泉']
del li[0:2]#   0=<x<2
print(li)
输出结果：
['刘康', '豆豆', '小龙', '李泉']

#####################强插知识点 range 、enumerate

1、请输出 1-10

　　2.7版本的pycharm: 使用range立即生成所有数字

range(1,11) # 生成 1,23，，4,56.10

　　3.x版本的pycharm: 不会立即生成，只有循环迭代时，才一个一个生成

for i in range(1,11):
    print(i)

for i in range(1,11,2): #2表示步长
    print(i)

for i in range(10,0,-1): #倒叙
    print(i)

　range小结：

　a) 3.x 不会立生成，迭代之后才一个一个创建；

     - 2.7：
　　　　range()
　　　　xrange() 不会立生成，迭代之后才一个一个创建；
     - 3.x
　　　　range() 不会立生成，迭代之后才一个一个创建；

   b) range: 三个参数

　　练习：输出元素，并在各个元素之前加上序号 li = ['reic','alex','tony']

#第一种方式
li = ['reic','alex','tony']
for i in range(0,len(li)):
    print(i+1,li[i])
输出结果：
1 reic
2 alex
3 tony

　　

#第二种方式
#enumerate额外生成一列有序的数字
li = ['reic','alex','tony']
for i ,ele in enumerate(li,1):
    print(i,ele)
v = input('请输入商品序号：')
v = int(v)
item = li[v-1]
print(item)
输出结果：
1 reic
2 alex
3 tony
请输入商品序号：1
reic

E、 元组 tuple

　　元组是一个特殊的列表，特殊在这个里面的元素创建完之后就不能被修改，意味着不能增删改

1、创建

user_tuple = ('alex','eric','seven')
print(user_tuple)
输出结果：
('alex', 'eric', 'seven')

2、count 获取个数

user_tuple = ('alex','eric','seven','alex')
v = user_tuple.count('alex')
print(v)
输出结果：
2

3、index 获取值的索引位置

user_tuple = ('alex','eric','seven','alex')
v = user_tuple.index('alex')
print(v)
输出结果：
0

4、额外

#1) 循环

user_tuple = ('alex','eric','seven','alex')
for i in user_tuple:
    print(i)
输出结果：
alex
eric
seven
alex

#2）按索引取值

user_tuple = ('alex','eric','seven','alex')
v = user_tuple[0]#按索引取值
print(v)
输出结果：
alex

　#3）取多个元素

user_tuple = ('alex','eric','seven','alex')
v = user_tuple[0:2]
print(v)
输出结果：
('alex', 'eric')

5、补充知识点

    有关元组的修改：

user_tuple = ('alex','eric','seven','alex',[1,2,3])#嵌套
user_tuple[0]=123#按照索引修改元组中的某个元素，不能修改
print(user_tuple)
返回结果：
TypeError: 'tuple' object does not support item assignment

　　

user_tuple = ('alex','eric','seven','alex',[1,2,3])#嵌套
user_tuple[3]=[11,22,33]#修改元组中的元素，元素是一个列表，不能修改
print(user_tuple)
返回结果：
TypeError: 'tuple' object does not support item assignment

　

user_tuple = ('alex','eric','seven','alex',['1','2','3'])#嵌套
user_tuple[4][1]='刘义' #修改第5个元素中的第二个元素，这个是可以修改的
print(user_tuple)
返回结果：
('alex', 'eric', 'seven', 'alex', ['1', '刘义', '3'])

总结：

元组的孩子不能被修改，孙子如果是可变的，可以被修改
li = ['alex',('eric','seven','alex') ]
列表里面包含元组，元组总的eric是不能被修改的，因为他是元组的孩子
潜规则：元组最后的那个元素后面 必须要加一个逗号,否则当只有一个元素的时候，无法区分是不是元组
li = ('alex','eric','seven','alex',)

F、字典 dict

　　可变类型，dic在pycharm里面很智能，打点就可以显示功能

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 = {'k1':'v1','k2':'v2'}
v = dic.get('k1111',1111)
print(v)
v = dic['k1111']
print(v)
输出结果：
1111
KeyError: 'k1111'

4、pop 删除并获取对应的value值

dic = {'k1':'v1','k2':'v2'}
v = dic.pop('k1')
print(dic)
print(v)
输出结果：
{'k2': 'v2'}
v1

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

dic = {'k1':'v1','k2':'v2'}
v = dic.popitem()
print(dic)
print(v)#v显示了元组的形式
输出结果：
{'k1': 'v1'}
('k2', 'v2')

　

dic = {'k1':'v1','k2':'v2'}
k,v = dic.popitem() # ('k2', 'v2')
print(dic)
print(k,v)
输出结果：
{'k2': 'v2'}
k1 v1

　　

dic = {'k1':'v1','k2':'v2'}
v = dic.popitem() # ('k2', 'v2')
print(dic)
print(v[0],v[1])
输出结果：
{'k1': 'v1'}
k2 v2

6、setdefault 增加，如果存在则不做操作

dic = {'k1':'v1','k2':'v2'}
dic.setdefault('k3','v3')
print(dic)
dic.setdefault('k1','1111111')
print(dic)
输出结果：
{'k3': 'v3', 'k1': 'v1', 'k2': 'v2'}
{'k3': 'v3', 'k1': 'v1', 'k2': 'v2'}

7、update 批量增加或修改

dic = {'k1':'v1','k2':'v2'}
dic.update({'k3':'v3','k1':'v24'})
print(dic)
输出结果：
{'k1': 'v24', 'k3': 'v3', 'k2': 'v2'}

8、fromkeys()方法从序列键和值设置为value来创建一个新的字典。

dic = dict.fromkeys(['k1','k2','k3'],123)
print(dic)
输出结果：
{'k2': 123, 'k1': 123, 'k3': 123}

　　

dic = dict.fromkeys(['k1','k2','k3'],123)
dic['k1'] = 'asdfjasldkf'
print(dic)
返回结果：
{'k2': 123, 'k3': 123, 'k1': 'asdfjasldkf'}

　　

dic = dict.fromkeys(['k1','k2','k3'],[1,])
dic['k1'].append(222)
print(dic)
返回结果：
{'k3': [1, 222], 'k1': [1, 222], 'k2': [1, 222]}

9、额外

a)那些值可以作为字典的key呢？字典key: 必须是不可变类型

dic = {
    'k1':'v1',
    'k2':[1,2,3,],
    (1,2,):'11111',
    True:'123',
    False:'1233',
    1:'ffffff',
    111:'afdf'
 }
print(dic)
返回结果：
{(1, 2): '11111', False: '1233', 'k2': [1, 2, 3], True: 'ffffff', 'k1': 'v1', 111: 'afdf'}

　#注意：元组中含列表不可以 (1,2,[1,2,3]):'11111', 这个 (1,2,[1,2,3])不可以作为字典的key

# key:
#     - 不可变
#     - True,1

b)删除字典的value

dic = {'k1':'v1'}
del dic['k1']
print(dic)
返回结果：
{}

G、set，集合

　　不可重负的列表；可变类型

1、创建

s1 = {"alex",'eric','tony','李泉','李泉11'}
print(s1)
输出结果：
{'eric', '李泉', '李泉11', 'alex', 'tony'}

2、difference s1中存在，s2中不存在

s1 = {"alex",'eric','tony','李泉','李泉11'}
s2 = {"alex",'eric','tony','刘一'}
v = s1.difference(s2)
print(v)
输出结果：
{'李泉11', '李泉'}

3、s1中存在，s2中不存在，然后对s1清空，然后在重新复制

s1 = {"alex",'eric','tony','李泉','李泉11'}
s2 = {"alex",'eric','tony','刘一'}
s1.difference_update(s2)
print(s1)
输出结果：
{'李泉11', '李泉'}

4、difference s2中存在，s1中不存在

s1 = {"alex",'eric','tony','李泉','李泉11'}
s2 = {"alex",'eric','tony','刘一'}
v = s2.difference(s1)
print(v)
输出结果：
{'刘一'}

5、difference  s2中存在，s1中不存在 s1中存在，s2中不存在

s1 = {"alex",'eric','tony','李泉','李泉11'}
s2 = {"alex",'eric','tony','刘一'}
v = s1.symmetric_difference(s2)
print(v)
输出结果：
{'刘一', '李泉', '李泉11'}

6、intersection 交集

s1 = {"alex",'eric','tony','李泉','李泉11'}
s2 = {"alex",'eric','tony','刘一'}
v = s1.intersection(s2)
print(v)
输出结果：
{'tony', 'alex', 'eric'}

7、union并集

s1 = {"alex",'eric','tony','李泉','李泉11'}
s2 = {"alex",'eric','tony','刘一'}
v = s1.union(s2)
print(v)
输出结果：
{'eric', '李泉', 'tony', 'alex', '李泉11', '刘一'}

8、discard 移除

s1 = {"alex",'eric','tony','李泉','李泉11'}
s1.discard('alex')
print(s1)
输出结果：
{'tony', '李泉', 'eric', '李泉11'}

9、update 增加

s1 = {"alex",'eric','tony','李泉','李泉11'}
s1.update({'alex','123123','fff'})
print(s1)
输出结果：
{'李泉', 'alex', '123123', '李泉11', 'eric', 'fff', 'tony'}

10、额外

a）循环

s1 = {"alex",'eric','tony','李泉','李泉11'}
for i in s1:
    print(i)
输出结果：
eric
李泉11
tony
alex
李泉

b)嵌套

s1 = {"alex",'eric','tony','李泉','李泉11',(11,22,33)}
for i in s1:
    print(i)
输出结果：
李泉
alex
tony
(11, 22, 33)
eric
李泉11