python学习笔记(二):字符串常用方法、字典、文件读写、元组

一、字符串常用方法

s = '   a   b asdf 112    '
print(s.strip())#去掉字符串两边的空格和换行符
print(s.lstrip())#去掉字符串左边的空格和换行符
print(s.rstrip())#去掉字符串右边的空格和换行符

测试结果：
a   b asdf 112
a   b asdf 112   a   b asdf 112

print(s.replace(" ",""))#替换

测试结果：
abasdf112

#查找
s = "abcdeaa"
#找下标
print(s.index('a'))#不存在的会报错
print(s.find('b'))#不存在的报-1

测试结果：
0
1

s = "abcdeaa"
#找某个字符出现的次数
print(s.count("a"))

测试结果：
3

s = "abcdeaa"
print(s.startswith('a'))#判断以什么开头
print(s.endswith('.jpg'))#判断以什么结尾

测试结果：
True
False

大小写转换
s = "abcDDDeaa"
print(s.upper())#把所有的字母变大写
print(s.lower())#把所有的字母变小写

测试结果：
ABCDDDEAA
abcdddeaa

s = "abcdeaa1213"
print(s.isupper())#字符串中的字母是否都是大写
print(s.islower())#字符串中的字母是否都是小写

测试结果：
False
True

s = "abcdeaa1213"
print(s.isdigit())#判断字符串里存的数据是否是整数

测试结果：
False

s = "1213"
print(s.isdigit())#判断字符串里存的数据是否是整数

测试结果：
True

s = "abcdeaa1213"
print(s.capitalize())#首字母大写

测试结果：
Abcdeaa1213

s = "abcdeaa1213"
print(s.center(50,'='))#把字符串放到50个=号之间

测试结果：
===================abcdeaa1213====================

s2 = "1"
print(s2.zfill(3))#在前面补0

测试结果：
001

s2 = "asdfadfQ好"
print(s2.isalpha())#是字母或汉字，返回True
print(s2.isalnum())#是数字或字母或汉字，返回True
print(s2.isspace())#判断是否是空格

解释结果：
True
True
False

#1.位置一一对应写法，位置不可以打乱
s3 = "今天是{},欢迎{}登录"
print(s3.format('2019','wangxiaoyu')) #做字符串格式化
# 如果变量多的话建议用format这种格式，不要用%s那种格式

s4 = 'insert into stu (id,username,passwd,phone) value ("{id}"，"{username}","{password}","{phone}")'
#2.key，vale写法，位置可以打乱
print(s4.format(username='abc',id=1,password='affsd',phone='122341'))#是先给每个占位起个名字，format后面就可以随便先写那个参数了
#3.json串写法，位置可以打乱
print(s4.format_map({"username":'abc',"id":1,"password":"affsd","phone":"sdfsfdsdf"}))


测试结果：
今天是2019,欢迎wangxiaoyu登录
insert into stu (id,username,passwd,phone) value ("1"，"abc","affsd","122341")
insert into stu (id,username,passwd,phone) value ("1"，"abc","affsd","sdfsfdsdf")

str = "wangxiaoyu,lixiaokai,liunhao"
print(str.split(','))#以逗号分割字符串
str2 = "wangxiaoyu      lixiaokai liunhao"
print(str2.split())#去掉所有空格并分割
str2 = "wangxiaoyu      lixiaokai liunhao"
print(str2.split(" "))#以空格分割

测试结果：
['wangxiaoyu', 'lixiaokai', 'liunhao']
['wangxiaoyu', 'lixiaokai', 'liunhao']
['wangxiaoyu', '', '', '', '', '', 'lixiaokai', 'liunhao']

import pprint
l = ['wangxiaoyu', 'lixiaokai', 'liunhao']
print(" ".join(l))
pprint.pprint(" ".join(l))#把list里面的每个元素通过制定的字符串链接起来，写文件的时候常用

测试结果：
wangxiaoyu lixiaokai liunhao
'wangxiaoyu lixiaokai liunhao'

 二、字典（集合）

info = {'name':'wangxiaoyu','age':'20'}

#增加key
info['sex'] = '女'#存在的话修改，不存在的话增加
print(info)
info.setdefault("sex2","女2")#不存在的话增加，存在的话不管
print(info)

测试结果：
{'name': 'wangxiaoyu', 'age': '20', 'sex': '女'}
{'name': 'wangxiaoyu', 'age': '20', 'sex': '女', 'sex2': '女2'}

info = {'name':'wangxiaoyu','age':'20'}
#修改
info['sex'] = 'gril'
print(info

测试结果：
{'name': 'wangxiaoyu', 'age': '20', 'sex': 'gril'}

#删除
info = {'name': 'wangxiaoyu', 'age': '20', 'sex': 'gril','score':'100'}
info.pop('age')
print(info)
del info['sex']
print(info)
info.popitem()#删除最后一个,一般不常用
print(info)

测试结果：
{'name': 'wangxiaoyu', 'sex': 'gril', 'score': '100'}
{'name': 'wangxiaoyu', 'score': '100'}
{'name': 'wangxiaoyu'}

info = {'name': 'wangxiaoyu', 'age': '20', 'sex': 'gril','score':'100'}

#取值
print(info['name'])#不存在会报错
print(info.get("name"))#不存在返回None，最好用get
print(info.get("name","wxytest"))#如果取不到，就返回wxytest


测试结果：
wangxiaoyu
wangxiaoyu
wangxiaoyu

info = {'name': 'wangxiaoyu', 'age': '20', 'sex': 'gril','score':'100'}
print(info.keys())#取字典中所有的key
print(info.values())#取字典中所有的value

测试结果：
dict_keys(['name', 'age', 'sex', 'score'])
dict_values(['wangxiaoyu', '20', 'gril', '100'])

info = {'name': 'wangxiaoyu', 'age': '20', 'sex': 'gril','score':'100'}
#清空
info.clear()
print(info)

测试结果：
{}

info = {'name': 'wangxiaoyu', 'age': '20', 'sex': 'gril','score':'100'}
#把集合info2添加到集合info中，若果，info中有，则修改，没有则添加，相当于list中的extend
info2 = {"name2":"wxy","score":"99.99"}
info.update(info2)
print(info)

测试结果：
{'name': 'wangxiaoyu', 'age': '20', 'sex': 'gril', 'score': '99.99', 'name2': 'wxy'}

info = {'name': 'wangxiaoyu', 'age': '20', 'sex': 'gril','score':'100'}
#判断key是否存在
# info.haskey('name')#python2
print('name' in info)#存在返回True，不存在返回False

测试结果：
True

stu_info  = {
    'liudonghai':{
        'house':['三环','四环','五环'],
        'car':{
            'china':['byd','五菱宏光','Hongqi'],
            'jap':['丰田','本田'],
            'Genmany':{
                'ben-z':2,
                'bmw':3,
                'audi':5
            }
        }
    }
}
#又买了一辆宝马（增加）
stu_info['liudonghai']['car']['Genmany']['bmw'] += 1
print(stu_info)
#把byd卖了（删除）
stu_info['liudonghai']['car']['china'].pop(0)
# stu_info['liudonghai']['car']['china'].remove('byd')
print(stu_info)

测试结果：
{'liudonghai': {'house': ['三环', '四环', '五环'], 'car': {'china': ['byd', '五菱宏光', 'Hongqi'], 'jap': ['丰田', '本田'], 'Genmany': {'ben-z': 2, 'bmw': 4, 'audi': 5}}}}
{'liudonghai': {'house': ['三环', '四环', '五环'], 'car': {'china': ['五菱宏光', 'Hongqi'], 'jap': ['丰田', '本田'], 'Genmany': {'ben-z': 2, 'bmw': 4, 'audi': 5}}}}

#循环字典

login = {'wangxiaoyu':'123456','lixiaokai':'111111'}

# 方法1，速度快，性能好，数据多的时候用该种方法
for i in login:
    print("%s => %s" % (i,login.get(i)))

测试结果：
wangxiaoyu => 123456
lixiaokai => 111111

#方法2
for k,v in login.items():
    print("%s => %s" % (k,v))

测试结果：
wangxiaoyu => 123456
lixiaokai => 111111

#循环list，就是循环list的里面的每个元素
l = ['wangxiaoyu', 'lixiaokai']

测试结果：
wangxiaoyu
lixiaokai

# 循环字符串，循环的就是字符串里面的每个元素
s = 'wangxiaoyu'
for x in l:
    print(x)
for y in s:
    print(y)

测试结果：
w
a
n
g
x
i
a
o
y
u

 三、文件读写

# 打开文件,三种模式，1，读模式r 2，写模式w 3，追加模式a

#1.读模式,只能读不能写，打开不存在的会报错
f = open('test.txt',encoding='utf-8')

# file() python2里还有的file
r = f.read()#读文件
print(r)
f.close()


测试结果：
aaa
bbbb
ccccc

#2.写模式，只能写不能读，会覆盖之前写的内容
f = open('test.txt','w',encoding='utf-8')
f.write('wangxiaoytest1')#只能写不能读
f.close()

测试结果：
写之前文件中内容为：
aaa
bbbb
ccccc
写之后文件中内容为：
wangxiaoytest1

#3.追加模式，只能写不能读，在原来文件的内容上增加新内容
f = open('test.txt','a',encoding='utf-8')
f.write('\nwangxiaoytest1')#只能写不能读
f.close()

测试结果：
写之前文件中内容为：
aaa
bbbb
ccccc
写之后文件中内容为：
aaa
bbbb
ccccc
wangxiaoytest1

# 三种模式，1，读写模式r+ 2，写读模式w+ 3，追加读模式a+
# 1.读写模式,只能读不能写，打开不存在的会报错
f = open('test.txt','r+',encoding='utf-8')
print("写之前读：\n%s" % f.read())#读文件
f.write("\n113")
f.seek(0)
print("写之后读：\n%s" % f.read())
f.close()

测试结果：
写之前读：
aaa
bbbb
ccccc
写之后读：
aaa
bbbb
ccccc
113

#2.写读模式，能读能写，会覆盖之前写的内容
f = open('test.txt','w+',encoding='utf-8')
f.seek(0)
print("写之前读：%s" % f.read())#读文件
f.write('123')
f.seek(0)
print("写之后读：%s" % f.read())#读文件
f.close()

测试结果：
写之前读：
写之后读：123

写之前读不到是因为写之前先把文件中的内容都删除了然后再写，所以写之前读到的是空

#3.追加模式，可读追加写，在原来文件的内容上增加新内容
f = open('test.txt','a+',encoding='utf-8')
f.seek(0)
print("写之前读：%s" % f.read())#因为指针在末尾，所以读不到，前面改变指针位置后就可以读到了
f.write('aaa')
f.seek(0)
print("写之后读：%s" % f.read())#读文件
f.close()

测试结果：
写之前读：aaa
bbbb
ccccc
写之后读：aaa
bbbb
cccccaaa

# 注意：只读的话可以用r 如果想读想写的话用a+和seek的组合

f = open(r'test.txt','a+',encoding='utf-8')
l  = ['a','b','c']
f.writelines(l)#把list的内容写到文件中

# f.write(l)#不能传list

测试结果：
写之前文件内容为空
写之后文件内容为：abc

f = open(r'/Users/wangxiaoyu/PycharmProjects/python_automated_development/day2/test.txt','a+',encoding='utf-8')
f.seek(0)#如果不加指针就读不到内容，因为指针在文件最后，读的时候从指针的位置开始往后读，所以读不到内容
print(f.readline())

测试结果：
文件中内容为：
aaa
bbbb
ccccc
读到的内容为：
aaa

f = open('test.txt',encoding='utf-8')
for l in f:
    print('每次循环的内容是：',l)

测试结果：
每次循环的内容是： aaa

每次循环的内容是： bbbb

每次循环的内容是： ccccc

#不需要关闭文件的写法
with open('test.txt') as f, open('test2.txt','w') as f2: # f = open('test.txt')
    print(f.read())
    f2.write('xx')

测试结果：
aaa
bbbb
ccccc

test2文件中的内容为：
xx

四、元组

#元组也是一个list，但是他不能修改

#不想让别人修改就可以用元组
t = ('192.168.1.1','root','123456',3306)

# 取值
print(t[0])
print(t.count('root'))#元素在元组中出现的次数
print(t.index('root'))#元素在元组中位置下标

测试结果：
192.168.1.1
1
1

t = ('192.168.1.1','root','123456',3306)
t1 = (1,)#元组里只有一个元素的话，后面一定要加一个逗号，这样他的类型才是元组
print(type(t1))

t1 = (1)#这样写不是元组
print(type(t1))

测试结果：
<class 'tuple'>
<class 'int'>

#字符串和元组一旦定义好都不能修改了，有些修改的函数均是返回一个新的字符串，而对原字符串并无影响
s = 'alsdjflasd'
print(s[0])#只能取，不能改
l = s.split('d')
print(l)#返回一个list
print(s)#原字符串没有被改变

测试结果：
a
['als', 'jflas', '']
alsdjflasd