python基础--字符串操作、列表、元组、文件操作

一、变量及条件判断
1.字符串、布尔类型、float、int类型，None都是不可变变量
2.字符串是不可变变量，不可变变量就是指定义之后不能修改它的值
3.count +=1和count=count+1是一样的
count-=1 count*=1 count/=1
内容补充：
None是空，代表什么都没有，但是它不是空字符串
if 条件判断的
or 与 a or b a、b 只要一个为True条件就为真
and 且 a and b a、b都为真，条件才为真
in 在不在它里面
is 判断的是内存地址是否一样
not 取反

说明：
1.!/usr/bin/python #python里面有个这个话，代表在linux下运行的时候去哪个目录下找python的解释器，在windows上运行不用写

2.指定字符集
coding:utf-8
__*__ coding:utf-8 __*__#这两种都在python2里面为了防止中文报错，修改字符集用的，python3里面不用写

二、字符串操作
1.字符串的字义
str = 'hello Imooc '

2.字符串访问
print str[1] #通过下标取值
字符串是可以通过下标来进行取值的，但是由于字符串是不可变变量，不能通过下票来修改它的值
注意：str[1]='E' #这种赋值方式是错的，字符串是不可变变量

3.for循环取字符串中的元素
for s in str:#python里面的for循环，每次循环的时候，循环的是循环对象里面的每一个元素
print(i) #输出str里面的每个元素
len(str)#取变量的长度

4.字符串的内置函数
str = 'hello Imooc '
import string
print(string.ascii_letters + string.digits) #大小写字母+数字
print(string.ascii_lowercase)#所有的小写字母
print('string.ascii_uppercase') #所有的大写字母
print('string.digits')#所有的数字

print(str.capatalize)#首字母大写，其它小写----->Hello imooc
print(str.center(30,''))#30个，把str放中间，str长度不够用*来补
print(str.endswith('c')) #是否以u结尾
print(str.expandtabs(30)) #补\t的次数
print(str.find('o'))#查找字符串的索引，找到的话返回第一次出现的索引，找不到返回-1
name = 'my \t name is {name},age is {age}.'
print(name.format(name='hhf',age=28))#格式字符串
print(name.format_map({'name':'hhf','age':19}))#这个也是格式化字符串，后面跟的是一个字典

print('abc111'.isalnum())#是否包含数字和字母
print('abA'.isalpha())#是否是英文字母
print('122'.isdigit())#是否是数字
print('aa'.isidentifier())#是否是一个合法的变量名
print('aa'.islower())#是否是小写字母
print('AA'.isupper())#是否是大写字母
print('Loadrunner Book'.istitle())#是不是一个标题，判断首字母是否大写
print('+'.join(['hehe','haha','ee']))#拼接字符串
print(name.lower())#变成小写
print(name.upper())#变成大写

print('\nmysql \n'.lstrip())#默认去掉左边的空格和换行
print('\nmysql \n'.rstrip())#默认去掉右边的空格和换行
print('\nmysql \n'.strip())#默认去掉两边边的空格和换行
print('mysqlm '.strip('m'))#当传入某个字符串的话，它只会去掉指定的字符

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))
print('mysql is db.'.replace('mysql','oracle',1))#替换字符串

print('mysql is is db'.rfind('is'))#返回最右边字符的下标
name1 = 'zcl p y zyz'
print(name1.split())#切割字符串，返回一个list，按照你指定的字符串去分隔这个字符串，然后放到一个list里面 #如果你什么都不写的话，按照空格分割，多个空格也算一个

print('1+2+3+4'.split('+'))#切割字符串，返回一个list
print('1+2+3\n1+2+3+4'.splitlines())#按照换行符分割
print('Abcdef'.swapcase())#大小写反转

注意：所有字符串的方法，它都不会修改原来字符串的值，都会产生一个新的字符串

5.字符串的切片
str = 'hello Imooc '
print(str[0:2]) #从第几个取到第几个，这个也是顾头不顾尾
s=[::-1]#如果步长为-1的时候，还有反转的功能
s=[:4]#如果是从第一个开始取，取到某一个下标结束，那么最前面是可以不写的
s=[1:]如果是从前面某个开始取，取到最后面结束，那么最后面是可以不写的

三、列表
1.列表的定义
a =['imooc',1,2,'zhangsan']

2.列表元素的访问
print a[1] #同字符串一样，列表是可以通过下标来访问的

3.修改列表的元素值
a[1]='aaa' #第2个元素修改为aaa ,修改的元素必须存在，否则会报错 #列表是可变变量，它是可以通下标修改值的
a[4]='bbb'#会报错

4.列表添加元素
a.append('lily') #给list从最末尾添加值
a.insert(1,'hhf')#指定位置添加元素

3.列表删除元素
print('pop返回值:',a.pop())#默认删除最后一个元素，删谁也把它的值返回了
a.pop(2) #删除指定位置的元素
a.remove('hhf')#删除指定的值，和pop的区别：pop删除元素，传的是下标，remove传的是一个元素的值
del a[0] #使用del关键字删除指定元素
del a #删除变量a，此时如果print a 就会报错
a.clear() #清空列表元素，此时list为空

4.列表内置方法
print(a.count('aa'))#查找值在list里面的次数
print(a.index('hhf')) #返回查找元素的下标，如果有多个话返回第一个的，如果没有的话，就会报错
print(a.index('hhf',2,3)) #后观可以加上查找开始位置和结束位置
stus = ['ccc‘,'ddd','fff']

print('加起来的',stus+a)#两个列表合并
print('这个是extend：',stus.extend(a))#把另一个列表里面的每个值挨个添加到前面的列表中

nums = [23,34,21,2,456,35,12324324]
nums.sort()#排序，默认是升序
print(nums.sort(reverse=True))#排序，指定reverse=True就是降序
nums.reverse()#反转数组，会改变原数组的值
print('hhf' in a)#用in来判断一个元素是否在list里面
print(a[-3])#下标是-1的话，代表最后一个元素

5.多维数组、列表、list
lis = [1,'lily',19.8,['lily','lilei',['heheh','haha']]]
取’haha的值‘，可以通过下面的方法取到
print(lis[3][2][1])

6.列表循环
a =['imooc',1,2,'zhangsan']
for name in a:#可以通过循环列表来获取，列表的元素值
print(name)

7.切片操作：
name1 = 'zcl,pyzyz'
names = ['zcl','py','zyz']#切片的意思就是从list里面或者字符串里面取几个元素 #切片操作对字符串也是完全适用的

print(names[0:2])#从第几个取到第几个，这个也是顾头不顾尾

print(names[:2])#如果是从第一个开始取，取到某一个下标结束，那么最前面是可以不写的

print(names[1:])#如果是从前面某个开始取，取到最后面结束，那么最后面是可以不写的

print(names[:])#如果最前面和最后面都不写的话，取整个列表

nums = list(range(1,11))
print(nums[1:10:2]) #如果最后面写上步长的话，就是每隔几个取一次
nums.reverse()#反转数组，会改变原来的数组
print(nums)
print(nums[::2])
print(nums[::-2])
print(nums[::-1])#当切片的步长为负数时，是从末尾开始取值的,然后隔几个取一次,如果步长为-1的时候，还有反转的功能

四、元组
1.元组的定义
tp = (1,2,3,4,5,6,1,1,1)
a='hello world' #这个是定义字符串
b=('hello world',) #这个是定义元组
print('this is',type(b)) #查看变量b的类型

2.元素值的访问
print(tp[0])

3.元组可用的方法
print(tp.count(1))
print(tp.index(1))#元组是一个不可变的list,只有count方法和index方法

注意：定义元组的时候，如果元组只有一个元素，那么你要在这个元素后面加一个逗号，要不然就是一个字符串

4.#强制类型转换函数
lis=['13','235']
new_lis = tuple(lis)#强制转换为元组
print(type(new_lis))#查看变量new_lis的变量类型
int()
float()
str()
list()
tuple()

五、字典
1.定义一个字典
info = {
'name':'xiaoming',
'sex':'nan',
'age':20,
'id':1,
}#字典里面的key是不能重复的

2.取字典中的值
print(info['id']) #通过key取值
print(info.get('id'))#通过key取值
--用中括号取值和get方法取值的区别 ，get方法获取不到key的时候不会报错，中括号取值找不到key会报错
--get方法还可以多传一个参数，如果get不到key的话，那么返回xx
--如果不写的话，默认get不到返回None
info['addr'] = 'Beijing'

3.给字典新增一个值
info.setdefault('phone',13811111) #给字典新增一个值
info['id'] = 7
--在有这个key的情况下那就是修改这个key的value
--没有这个key的话，就是新增

4.删除元素
说明：字典是无序的
del info['addr'] #通过del关键字删除字典的一个元素
info.pop('name')#pop删除的时候必须得指定key，pop方法会返回删除的key对应的value pop方法删除元素有返回值
info.popitem()#随机删除一个元素
info.clear()#清空字典

查看下列元素的访问
all = {
'car':
{
'color':['red','yellow','black'],
'moeny':1111111,
'pailiang':"2.5L",
'name':"BMW"
} ,
'car1':
{
'color':['red','yellow','black'],
'moeny':1111111,
'pailiang':"2.5L",
'country':"china"
},
'car2':
{
'color':['red','yellow','black'],
'moeny':1111111,
'pailiang':"2.5L"
}

}
（1）将car中的color改为orange
all.get('car').get('color')[1] = 'orange'
all['car']['color'][1]='orange'
print(all)

5.字典的内置方法
names= {'a1':'anan','a2':'lily','a3':'leilei'}
print(names.keys())#获取该字典的所有key
print(names.values())#获取该字典所有的value
print(names.items())#获取字典的key和value，循环的时候用
print(names.setdefault('a1','fengluo'))#如果这个key存在的话，那就不动它，不存在的话，添加一个
name2 = {'a1':'sriba','stu10':'baidu'}
names.update(name2)#更新字典值，如果key存在的话，就更新值，不存在的话就添加
print(names.items())#字典转换成一个list

6.字典的循环
--直接循环字典循环的是字典的key，如果想循环的时候同时获取到key和value,那么就要用.items方法
info2 = {
'name':"hhh",
'sex':'nan'
}
info.update(info2)#把两个字典合并到一起，如果有一样的key，那么更新value
print(info)

print(info2.items())

for k,v in info.items():#items方法的作用就是为了让你循环的时候同时把key和value取到
print('%s is %s'%(k,v))

for k in info2:
print(k,info2[k])
--第二种方式效率比较高

info.has_key('name')
说明：
python2里面有这个方法，是判断key是不是存在的
python3里面没有 print('name' in info2)
python3里面直接用in来判断key是否存在

六、文件操作
1.文件的读写步骤：
（1）先打开文件
（2）读取/写入内容
（3）保存文件

2.打开文件
文件的打开模式有3种：
（1）w写模式，它是不能读的，如果用w模式打开一个已经存在的文件，会清空以前的文件内容，重新写
w+模式，写读模式，只要沾上w，肯定会清空原来的文件
（2）r读模式，只能读，不能写，而且文件必须存在
r+是读写模式，只要沾上r，文件必须得存在
（3）a追加模式，也是只能写，在文件的末尾添加内容
a+追加读写模式，文件存在只追加内容，不存在则创建
注意：使用a模式的时候，应该注意文件指针的位置
（4）rb+、wb+、ab+,这种是二进制模式打开或者读取，一些音乐文件、图片等等

fw = file('a.txt','r')
--如果在打开文件的时候，不指定模式，那就是读模式
--在python2里面也可以用file这个函数去操作文件，但是在Python3里面只能用open

f= open('C:\Users\Desktop\jmeter_script\aaa.txt','r')
f= open('C:/Users/Desktop/jmeter_script/aaa.txt','r')
--打开某个目录下的文件

f = open('a.txt','a+',encoding='utf-8') #f代表的是这个文件的对象，也叫句柄
--encoding参数可以指定文件的编码

3.读文件
print(f.read()）#读文件内容，返回的是一个字符串
print(f.readline())#只读文件一行的内容
print(f.readlines())#读文件的内容，返回的是一个列表
注意：
f.read()#读取所有内容，大文件时不要用，因为会把文件内容都读到内存中，内存不够的话，会把内存撑爆
f.readlines()#读取所有文件内容，返回一个list，元素是每行的数据，大文件时不要用，因为会把文件内容都读到内存中，内存不够的话，会把内存撑爆

4.文件的循环
文件对象也是可迭代的，直接循环文件的话，循环的是文件每一行的内容
f= open(aaa.txt','r')
for name in f:
print(name)
f.close()

5.写文件
f.write('zhangsan') #写文件的时候，只能是字符串
f.writelines(['123','456'])#可以把列表写到里面

6.文件指针
f.tell()#获取当前文件的指针指向
f.seek(0) #把当前文件指针指向哪

7..文件关闭
f.close()#关闭文件

8.文件操作的其它方法
f.readable()#判断文件是否可读
f.writeable()#判断文件是否可写
f.flush()#写入文件后，立即从内存中据数据写到磁盘中
f.truncate()#清空文件内容
例如：
--flush用法
import time
fw = open('python.txt','w',encoding='utf-8')
fw.write('下周不上课！')
fw.flush()#写完之后立马生效
exit('拜拜')
time.sleep(30)
fw.close()

9.文件修改
修改文件的话，有两种方式：
一种是把文件的全部内容都读到内存中，然后把原有的文件内容清空，重新写新的内容；
第二种是把修改后的文件内容写到一个新的文件中
第一种
with open('file.txt','r+') as fr:
res = fr.read()
fr.seek(0)
fr.truncate()#清空文件内容
new_res = res.replace('nibuhao','my')
fr.write(new_res)

没有用with方法
f = open('file.txt','r+')
res = f.read()
f.seek(0)
f.truncate() # 清空文件内容
new_res = res.replace('me', 'nibuhao')
f.write(new_res)
f.close()

第二种
import
with open('file.txt') as fr,open('file_new','w') as fw: #这个是多文件的操作，打开两个文件，fr是读file.txt，fw是新建一个file_new文件
for line in fr:#循环file.txt中的每一行
new_line = line.replace('我','me')
fw.write(new_line)#写到file_new文件中
os.remove('file.txt')#删除文件
os.rename('file_new','file.txt')#文件重命名

没有用with的方法
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')#文件重命名

6.大文件时，读取文件高效的方法：
大文件时，读取文件高效的操作方法：
用read()和readlines()方法操作文件的话，会先把文件所有内容读到内存中，这样的话，内存数据一多，非常卡，高效的操作，就是读一行操作一行，读过的内容就从内存中释放了
f=open('aa.txt')
for line in f:
print(line)#line是每行文件的内容，读完一行的话，就会释放一行的内存

with使用：
在操作文件的时候，经常忘记了关闭文件，这样的就可以使用with，它会在使用完这个文件句柄之后，自动关闭该文件，使用方法如下：
with open('aa.txt','r') as f:#打开一个文件，把这个文件的句柄给f
for line in f:
print(line)

with open('aa1.txt') as f1,open('aa2.txt','w') as f2:#这个是多文件的操作，打开两个文件，f1是读aa1.txt,f2是新建一个aa2.txt文件
for line in f1:#循环aa1.txt中的每一行
f2.write(line) #写到aa2.txt文件中