Python自动化课之Day3篇
Part 1, 对于上节课的补充
1. 数据类型--None类型：(字符串是不可变变量，不可变变量就是指定义之后不能修改它的值)
None是空，代表什么都没有，但是它不是空字符串.
而''，是一个字符串对象，代表一个空的字符串。
count+=1和count = count +1是一样
count-=1
count*=1
count/=1
2.if 条件判断的
or and
in 在不在它里面
例：
names='lj,zhx,zhwq,zhwx'
print('lj' in names)
输出：True
is 判断的是内存地址一样不一样
例：
name1='lj'
name2='lj'
print(name1 is name2)
输出：True
#print(id(变量））可看内存地址
not 取反
例：
names='lj,zhx,zhwq,zhwx'
print('lj' not in names)
输出： False
Part 2, Python数据类型
一，字符串和字符串操作
1，字符串是可以通过下标（索引）来进行取值的，但是由于字符串是不可变变量，不能通过下标来修改它的值
username = 'li'
username[0]
例：
names='lj,zhx,zhwq,zhwx'
print(names[0:6])
输出：lj,zhx
python里面的for循环，每次循环的时候，循环的是循环对象里面的每一个元素
例：
names='lj,zhx,zhwq,zhwx'
for name in names:
print(name)
等于：（python里不要这么写）
names='lj,zhx,zhwq,zhwx'
for i in range(len(names)): #len(names)#取变量的长度
print(names[i])
二，列表
!/usr/bin/python #python里面有个这个话，代表在linux下运行的时候去哪个目录下找python的解释器，在windows上运行不用写
coding:utf-8和 __*__ coding:utf-8 __*__ 这两种都在python2里面为了防止中文报错，修改字符集用的，python3里面不用写
列表也叫数组，列表定义，使用[]即可；列表里面可以再套列表，一个里面套一个列表，叫二维数组；一个里面套一个列表，里面的列表再套一个列表，这个叫三维数组，套几层就是几维
定义列表： names=[1,2,3,'LJ',"ZHX"]
通过下标取值：print(names[3]) -->输出：LJ
列表是可变变量，它是可以通下标修改值的
修改值：names[0]='zhwq' (print(names) 输出：['zhwq',2,3,'LJ',''ZHX''])
对列表的操作，分以下几种增、删、改、查
增：
给list从最末尾添加值: names.append('ZHWX') (print(names) 输出：['zhwq',2,3,'LJ',''ZHX'','ZHWX'])
指定位置添加元素: names.insert(0,'libby') (print(names) 输出：['libby','zhwq',2,3,'LJ',''ZHX'','ZHWX'])
删：
names.pop() 默认删除最后一个元素,删谁也把它的值返回了 (print(names) 输出：['libby','zhwq',2,3,'LJ',''ZHX''])
names.pop(2) 删除指定位置的元素 (print(names) 输出：['libby','zhwq',3,'LJ',''ZHX'','ZHWX'])
或使用del关键字删除指定元素 ：del names[2]
清空列表:
names.clear()
删除指定的元素： 要和pop方法区别开来，pop如果删除的话，传是下标
names.remove('libby')
查找值在list里面的次数:print(names.count('LJ')) -->输出：1
用in来判断一个元素是否在list里面：print('LJ' in names) -->看输出True/ False
查：
下标是-1的话，代表最后一个元素 ：print(names[-1])
一些内置方法：
names=['libby',1,2,3,'LJ',"ZHX",'zhwx']
print(name.index('LJ')) #返回查找元素的下标，如果有多个话返回第一个的，如果没有的话就会报错
print(name.index('LJ',2,5)) #后面可以加上查找开始位置和结束位置
两个列表相加：
stu=['peggy','LYX','wm']
print(stu+names) 输出：['peggy', 'LYX', 'wm', 'libby', 1, 2, 3, 'LJ', 'ZHX', 'zhwx']
把另一个列表里面的每个值挨个添加到前面的列表中：
stu.extend(names)
print(stu) 输出：['peggy', 'LYX', 'wm', 'libby', 1, 2, 3, 'LJ', 'ZHX', 'zhwx']
排序：
nums=[23,34,1,2,345,7,9,343555]
nums.sort() #默认是升序
print(nums)
输出：[1, 2, 7, 9, 23, 34, 345, 343555]
nums.sort(reverse=True) #指定reverse=True就是降序
print(nums)
输出：[343555, 345, 34, 23, 9, 7, 2, 1]
nums.reverse() #反转数组，会改变原数组的值
print(nums)
输出：[343555, 9, 7, 345, 2, 1, 34, 23]
多维数组（列表，list）：
lis=[1,'lily',19.8,['lily','lilei',['heheh','haha']]]
print(lis[3][2][1])
输出：haha
三，字符串方法
所有字符串的方法，它都不会修改原来字符串的值，都会产生一个新的字符串
name='hello world'
print(name.capitalize()) 输出：Hello world #首字母大写
print(name.center(100,'*')) 输出：********************************************hello world********************************************* #100个*，把name放中间
print(name.endswith('d')) 输出：True #判断字符串是否以“d”结尾
print(name.find('world')) 输出：6 #查找字符串的索引，找到的话返回第一次出现的索引，找不到返回-1
print(name.format(name='niuniu', age=18)) #格式化字符串
print(name.format_map({'name':'niuniu','age':19})) #这个也是格式化字符串，后面跟的是一个字典
print('abA123'.isalnum()) 输出：True #判断字符串是否包含数字和字母
print('abA'.isalpha()) 输出：True #判断字符串是否是英文字母
print('122'.isdigit()) 输出：True #判断字符串是否是数字
print('aa'.isidentifier()) 输出：True #判断是否是一个合法的变量名
print('aa'.islower()) 输出：True #判断是否是小写字母
print('AA'.isupper()) 输出：True #判断是否是大写字母
print(name.upper()) 输出：HELLO WORLD #变成大写
print(name.lower()) 输出：hello world #变成小写
names=['LJ','ZHX','sffffff']
print('+'.join(names)) 输出：LJ+ZHX+sffffff
或
strname='ABCDEF'
print('&'.join(strname)) 输出：A&B&C&D&E&F #join是用来通过某个字符串拼接一个可迭代对象的的每个元素的
print('\nmysql \n'.lstrip()) #默认去掉左边的空格和换行
print('\nmysql \n'.rstrip()) #默认去掉右边的空格和换行
print('\nmysql \n'.strip()) #默认去掉两边边的空格和换行
print('mysqlm '.strip('m')) 输出：ysql #当你传入某个字符串的话，它就只会去掉你指定的字符串
p = str.maketrans('abcdefg','1234567') #前面的字符串和后面的字符串做映射
print('cc ae gg'.translate(p)) #输出按照上面maketrans做映射后的字符串
#下面是反解
new_p = str.maketrans('1234567','abcdefg')
print('cc ae gg'.translate(new_p))
str='mysql is db...mysql mysql mysql'
print(str.replace('mysql','oracle',1)) 输出：oracle is db...mysql mysql mysql # 替换字符串
print('mysql is is db'.rfind('is')) 输出：9 #返回最右边字符的下标
name1='LJ,ZHX,sffffff'
print(name1.split(',')) 输出：['LJ', 'ZHX', 'sffffff']
#切割字符串，返回一个list，按照你指定的字符串去分隔这个字符串，然后放到一个list里面
如果你什么都不写的话，按照空格分割，多个空格也算一个
print('1+2+3\n1+2+3+4'.splitlines()) #按照换行符分割
print('Abcdef'.swapcase()) #大小写反转
import string
print(string.ascii_letters+string.digits) 输出：abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 #所有的大小写字母加数字
print(string.ascii_lowercase) #所有的小写字母
print(string.ascii_uppercase) #所有的大写字母
print(string.digits) #所有的数字
四，切片
切片，切片也就是另一种方式获取列表的值，它可以获取多个元素，可以理解为，从第几个元素开始，到第几个元素结束，获取他们之间的值，格式是name:[1:10]，比如说要获取name的第一个元素到第五个元素，就可以用name[0:6]，切片是不包含后面那个元素的值的，记住顾头不顾尾；前面的下标如果是0的话，可以省略不写，这样写，name[:6]，切片后面还有可以写一个参数，叫做步长，也就是隔多少个元素，取一次，默认可以不写，也就是隔一个取一次，切片操作也可以对字符串使用，和列表的用法一样。
names = ['zcl','py','zyz'] #切片的意思就是从list里面或者字符串里面取几个元素
print(names[0:2]) 输出：['zcl', 'py'] #从第几个取到第几个，这个也是顾头不顾尾
print(names[:2]) #如果是从第一个开始取，取到某一个下标结束，那么最前面是可以不写的
print(names[1:]) #如果是从前面某个开始取，取到最后面结束，那么最后面是可以不写的
print(names[:]) #如果最前面和最后面都不写的话，取整个列表
切片操作对字符串也是完全适用的
name1='zcl,pyzyz'
print(name1[1:5]) 输出：cl,p
nums=list(range(1,21))
print(nums[0:10:2]) #如果最后面写上步长的话，就是每隔几个取一次
print(nums[::-1]) #当切片的步长为负数时，是从末尾开始取值的,然后隔几个取一次
#如果步长为-1的时候，还有反转的功能 （和nums.reverse() 效果一样）
五，元组
元组其实和列表一样，不一样的是，元组的值不能改变，一旦创建，就不能再改变了，比如说，要存数据库的连接信息，这个连接信息在程序运行中是不能被改变的，如果变了那数据库连不上了，就程序就完犊子了，这样的就可以使用元组了，元组呢，也提示别人，看到是元组的话，就说明这个值是不能被改变的
元组的定义方式是用()，小括号，定义元组的时候，如果元组只有一个元素，那么你要在这个元素后面加一个逗号，要不然就是一个字符串。
元组只有两个方法，那就是count和index
例：
tp=(1,2,3,4,5,6,1,1,1)
print(tp[0]) 输出：1
print(tp.count(1)) 输出：4
print(tp.index(1)) 输出：0
lis=['1','2323']
new_lis=tuple(lis) （强制类型转换）
print(type(new_lis)) 输出： <class 'tuple'>
已学强制类型转换：
#int()
#float()
#str()
#list()
#tuple()
六，字典
字典也是我们开发过程中最常用的一种数据类型，字典dict，全称是dictionary，它具有极快的查找速度；字典是一种key-value的数据类型，比如说要存每个人的信息，那么每个人的编号就是key，value就是每个人的信息，这样的话，一个字典就能存所有人的信息了。字典的定义使用{}，大括号，每个值用“，”隔开，key和value使用“：”分隔。字典里的Key是不能重复的。
例：
info={'name':'xiaoming',
'sex':'nan',
'age':20,
'id':1}
取值： print(info['name']) 输出：xiaoming
print(info['id']) 输出：1
print(info.get('id')) 输出：1
print(info['addr']) 报错
print(info.get('addr')) 输出：None
#用中括号取值和get方法取值的区别，get方法获取不到Key的时候不会报错，中括号取值找不到Key会报错
print(info.get('addr','beijing')) 输出：beijing
#get方法还可以多传一个参数，如果get不到key的话，那么返回**，如果不写的话，默认get不到返回None.
增加：
info['addr']='beijing' #给字典新增一个值
print(info)
输出：{'addr': 'beijing', 'sex': 'nan', 'age': 20, 'id': 1, 'name': 'xiaoming'}
info.setdefault('phone',13811111) #给字典新增一个值
print(info)
输出：{'phone': 13811111, 'sex': 'nan', 'name': 'xiaoming', 'id': 1, 'age': 20}
修改：
info['id']=7 #在有这个key的情况下，就是修改这个Key的value,没有这个Key的话，就是新增。
print(info)
输出：{'id': 7, 'age': 20, 'name': 'xiaoming', 'sex': 'nan'}
删除：
del info['id']
print(info)
输出：{'sex': 'nan', 'name': 'xiaoming', 'age': 20}
或者
info.pop('id') #字典是无序的，pop删除的时候必须指定key，pop方法会返回删除的key对应的value
print(info)
输出：{'sex': 'nan', 'name': 'xiaoming', 'age': 20
info.clear() #清空字典
info.popitem() #随机删除一个元素
字典的一些内置方法：
all={'car':{'color':['red','yellow','black'],
'money':111111,
'pailiang':'2.5L',
'name':'BMW'
},
'car1':{'color':['red','yellow','black'],
'money':111111,
'pailiang':'2.5L',
'name':'China'
},
'car2':{'color':['red','yellow','black'],
'money':111111,
'pailiang':'2.5L'
}
}
取car里yellow的值：
print(all.get('car').get('color')[1])
修改car里yellow的值为orange:
all.get('car').get('color')[1]='orange'
print(all)
print(all.keys()) 输出：dict_keys(['car2', 'car', 'car1']) #获取该字典的所有Key
print(all.values()) #获取该字典所有的value
print(all.items()) #获取字典的key和value,循环的时候用
直接循环字典循环的是字典的key，如果想循环的时候同时获取到key和value,那么就要用.item方法。items方法的作用就是为了让你循环的时候同时把key和value取到。输出的是列表，效率比较低。
for k in all:
print(k,all[k]) #这种方法取值效率比较高
info.update(all) #把两个字典合并到一起，如果有一样的key,那么更新value.
print(info)
info.has_key('name') #python2里有这个方法，来判断key是否存在，python3里没有
print('name' in info) #python3里面直接用in来判断key是否存在
，
七，文件读写
文件打开模式有三种
1，w写模式，它是不能读的，如果用w模式打开一个已经存在的文件，会清空以前的文件内容，重新写。
w+写读模式，只要沾上w,肯定会清空原来的文件
2，r读模式，只能读，不能写，而且文件必须存在
r+读写模式，只要沾上r，文件必须存在
3，a追加模式，也是只能写不能读，在文件的末尾添加内容
4，rb+,wb+,ab+，这种是二进制模式打开或读取，一些音乐文件，图片等。
fw=file('a.txt','r')
#在python2里面可以用file这个函数去操作文件，但是在python3里面只能用open
f=open('a.txt','r',encoding='utf-8')
print(f.read()) #读文件内容，返回的是一个字符串
print(f.readlines()) #读文件内容，返回的是一个列表
print(f.readline()) #只读文件一行的内容
f.write('lj') #写文件的时候，只能是字符串
f.writelines(['123','456','789']) #可以把列表写到文件里面
f=open('a.txt')
#如果在打开文件的时候，不指定模式，那就是读模式
f=open('a.txt','a+') #f代表的是这个文件的对象，也叫句柄
f.seek(0) #移动文件指针
#文件对象也是可迭代的
print(f.read())
for line in f:
print(line) #直接循环文件对象的话，循环的是文件每一行的内容
修改文件：
修改文件的话，有两种方式，一种是把文件的全部内容都读到内存中，然后把原有的文件内容清空，重新写新的内容；第二种是把修改后的文件内容写到一个新的文件中
第一种：
f=open('a.txt1','a+',encoding='utf-8')
f.seek(0)
res=f.read()
f.seek(0)
f.truncate() #清空文件内容
new_res=res.replace('nihao','nibuhao')
f.write(new_res)
第二种：
import os
f=open('a.txt','a+',encoding='utf-8')
f.seek(0)
fw=open('a.txt.new','w',encoding='utf-8')
for line in f:
new_res=line.replace('学','不学')
fw.write(new_res)
f.close() #关闭文件
fw.close()
os.remove('a.txt')
os.rename('a.txt.new','a.txt')
Flush用法：
import time
fw=open('python.txt','w',encoding='utf-8')
fw.write('更新博客')
fw.flush() #写完之后立马生效
time.sleep(30)
fw.close()
With用法：文件不再用的时候，就会自动关闭该文件
with open('python.txt',encoding='utf-8') as fr:
print(fr.read())
