Python Day2

741057228我QQ

字符串类型
　　字符串只能存一个值，有序，不可变

当前阶段重点
　　strip() 移除空白，去除指定字符串
　　只能去除开头或结尾的连续字符串，中间的无法去掉，默认是去除空格，（）里面可以写其它字符串
　　

#举例一　　
password=input('>>> ')
　　
#第一种用法
　　
# password=password.strip()
　　
# print(password)
　　
#第二种用法
　　
#print(password.strip())
　　

　　
#举例二
　　
msg='***dzm*****'
　　
print(msg.strip('*'))
　　
dzm
　　

　　split()切分，以某一个指定的字符串，将一长串字符切分成一个列表，默认按照空格切分
　　split()有两个主要的参数，第一个是指定分割符，第二个是切成几段
　　

#举例一　　
user_info='root:0:0::/root:/bin/bash'
　　
print(user_info.split(':'))
　　
['root', '0', '0', '', '/root', '/bin/bash']
　　
print(user_info.split(':')[0])
　　
root
　　
#举例二 指定切几次
　　
print(user_info.split(':',1))
　　
['root', '0:0::/root:/bin/bash']
　　
#举例三
　　
user_list='root:x:0:0::dafeaefa'
　　
print(user_list.split(':')[0])
　　
root
　　

　　#join 将列表使用指定字符拼接成一个字符串，可以用空格
　　

user_list='root:x:0:0::dafeaefa'　　
l=user_list.split(':')
　　
print(l)
　　
['root', 'x', '0', '0', '', 'dafeaefa']
　　
print(':'.join(l))
　　
root:x:0:0::dafeaefa
　　
print(''.join(l))
　　
rootx00dafeaefa
　　

　　拼接出unix风格路径
　　

dirs = '', 'usr', 'bin', 'env'　　
print('/'.join(dirs))
　　
结果：
　　
/usr/bin/env
　　

　　拼接出DOS风格路径
　　

print('C:' + '\\'.join(dirs))　　
结果：
　　
C:\usr\bin\env
　　

　　#判断数字
　　#在python3中
　　#isdigit 判断字符串里面是不是纯数字
　　

num1=b'4' #bytes　　
num2=u'4' #unicode,python3中无需加u就是unicode
　　
num3='四' #中文数字
　　
num4='肆' #中文繁体
　　
num5='Ⅳ' #罗马数字
　　
print(num1.isdigit())
　　
print(num2.isdigit())
　　
print(num3.isdigit())
　　
print(num4.isdigit())
　　
print(num5.isdigit())
　　
True
　　
True
　　
False
　　
False
　　
False
　　

需要了解
　　移除左右空白
　　

msg='***dzm*****'　　
# print(msg.lstrip('*')) #只切掉左边的
　　
# dzm*****
　　
#print(msg.rstrip('*'))#只切掉右边的
　　
#***dzm
　　

　　判断已什么开头和已什么结尾，输出结果是布尔值
　　

msg='dzm_good'　　
# print(msg.startswith('dzm'))
　　
# True
　　
# print(msg.endswith('good'))
　　
# True
　　

　　方法replace将指定子串都替换为另一个字符串，并返回替换后的结果
　　替换字符串，第一个值为被替换的字符串，第二个为替换后的，第三个值为替换几个，不写为全部替换
　　替换字符串并不会改变原来的变量赋值，而是得到一个新的字符串
　　

msg='my name is dzm , dzm is my'　　
print(msg.replace('dzm','mdz'))
　　
my name is mdz , mdz is my
　　

　　
print(msg.replace('dzm','mdz',1))
　　
my name is mdz , dzm is my
　　

　　format 类似格式化输出，但可以让你不再依赖位置去传值
　　

#第一种用法　　
# print('my name is {},my age is {}'.format('dzm',18))
　　
# my name is dzm,my age is 18
　　
#第二种用法
　　
# print('{0},{1},{0}'.format('dzm', 18))
　　
# dzm,18,dzm
　　
#第三种用法，不依赖位置
　　
# print('my name is {x},my age is {y}'.format(x='dzm',y=18))
　　
# my name is dzm,my age is 18
　　

　　#find 从左到右找，如果有，返回第一个字符的索引
　　#如果找不到返回-1
　　#可以用来判断有没有匹配字符串，也可以指定范围找（顾头不顾尾）
　　#还有个rfind，是从右往左找
　　

msg='hello,world'　　
print(msg.find('ell'))
　　
1
　　
print(msg.find('l',0,5))
　　
2
　　

　　index 索引，从左到右找，如果有，返回第一个字符的索引
　　纯找索引，找不到会报错
　　还有个rindex，是从右往左找
　　

msg='hello,world'　　
# print(msg.index('ell'))
　　
# 1
　　
print(msg.index('dzm'))
　　
#找不到，直接报错
　　
print(msg.index('l',4,8)) #也可以指定范围找（顾头不顾尾）
　　

　　count统计有多少个字符串
　　

# msg='hello,world'　　
# print(msg.count('l'))
　　
# 3
　　
# print(msg.count('l',0,4))
　　
# 2
　　

　　#center ljust rjust zfill 四个都是填充功能
　　让指定字符串居中显示，两边按总长度自动填充指定字符
　　#ljust，rjust 在左边填充和在右边填充
　　#有两个参数，第一个是指定字符串长度（宽度），第二个是用什么填充
　　

#print('dzm'.center(30,'='))　　
#=============dzm==============
　　
# print('dzm'.ljust(30,'='))
　　
# dzm===========================
　　
# print('dzm'.rjust(30,'='))
　　
# ===========================dzm
　　
#zfill从左边用0填充
　　
print('dzm'.zfill(30))
　　
000000000000000000000000000dzm
　　

　　#capitalize 首字母大写
　　

msg='my name is dzm'　　

　　#upper 全部变成大写
　　

print(msg.upper())　　
MY NAME IS DZM
　　

　　#lower 全部转换成小写
　　

msg='My name is DZM'　　
print(msg.lower())
　　
my name is dzm
　　

　　#判断是否全部大写或全部小写
　　

msg='My name is DZM'　　
print(msg.isupper()) #判断是否全部是大写
　　
False
　　
print(msg.islower()) #判断是否全部是小写
　　
False
　　

　　#判断字符串是否有字母和数字组成
　　

# msg='abc123'　　
# print(msg.isalnum())
　　
# True
　　

　　#判断字符串是否由纯字母组成
　　

# msg='abcdef'　　
# print(msg.isalpha())
　　
# True
　　

列表类型
　　列表是可变类型
　　#优先掌握的操作
　　#按索引存取值（正存取和反存取），即可存也可取
　　

name_list=['dzm','alex','egon',4,5]　　
# print(name_list[1])
　　
# alex
　　
# print(name_list[-1])
　　
# 5
　　
#修改
　　
# name_list[0]='oldboy'
　　
# print(name_list)
　　
# # ['oldboy', 'alex', 'egon', 4, 5]
　　

　　
print(input_cmd[-2], input_cmd[-1])  #取最后两个数据
　　

　　#切片，顾头不顾尾，步长
　　

name_list=['dzm','alex','egon',4,5]　　
# print(name_list[0:2])
　　
# ['dzm', 'alex']
　　
# print(name_list[0::2])
　　
# ['dzm', 'egon', 5]
　　

　　使用切片赋值还可在不替换原有元素的情况下插入新元素
　　

numbers = [1, 5]　　
numbers[1:1] = [2, 3, 4]
　　
numbers
　　
[1, 2, 3, 4, 5]
　　
这里我“替换”了一个空切片，相当于插入了一个序列
　　

　　清空
　　

lst = [1, 2, 3]　　
lst.clear()
　　
lst
　　
[]
　　

　　#长度,显示列表中有几个元素
　　

name_list=['dzm','alex','egon',4,5]　　
print(len(name_list))
　　
5
　　

　　#成员运算 in 和 not in
　　#判断某个元素是否在列表中
　　

# name_list=['dzm','alex','egon',4,5]　　
# print('dzm' in name_list)
　　
# True
　　
# print(5 in name_list)
　　
# True
　　

　　#追加
　　#append 默认加到最后面
　　

# name_list=['dzm','alex','egon',4,5]　　
# name_list.append('oldboy')
　　
# print(name_list)
　　
# ['dzm', 'alex', 'egon', 4, 5, 'oldboy']
　　

　　#删除
　　

#del是一种通用的删除方法，并非列表专用　　
name_list=['dzm','alex','egon',4,5]
　　
del name_list[0]
　　
print(name_list)
　　
['alex', 'egon', 4, 5]
　　

#remove 直接指定元素进行删除，是单纯的删除　　
name_list.remove('dzm')
　　
print(name_list)
　　
['alex', 'egon', 4, 5]
　　

　　pop 按照索引从列表中取走元素，等于是剪切，默认取走最后一个
　　

name_list=['dzm','alex','egon',4,5]　　
name_list.pop()
　　
print(name_list)
　　
['dzm', 'alex', 'egon', 4]
　　
name_list.pop(1)
　　
print(name_list)
　　
['dzm', 'egon', 4, 5]
　　

　　赋值，将列表索引为1的元素赋值给一个新变量
　　

res=name_list.pop(1)　　
print(res)
　　
alex
　　

　　#常用操作
　　#insert 按照索引位置去插入值
　　

name_list=['dzm','alex','egon',4,5]　　
name_list.insert(1,'oldboy')
　　
print(name_list)
　　
['dzm', 'oldboy', 'alex', 'egon', 4, 5]
　　

　　#extend 加多个值
　　

name_list=['dzm','alex','egon',4,5]　　
name_list.extend([6,7,8])
　　
print(name_list)
　　
['dzm', 'alex', 'egon', 4, 5, 6, 7, 8]
　　

　　#count 统计指定元素的个数
　　

name_list=['dzm','alex','egon',4,5,'dzm']　　
print(name_list.count('dzm'))
　　
2
　　

　　#了解的内容
　　#copy 拷贝一个新列表
　　

name_list=['dzm','alex','egon',4,5]　　
l=name_list.copy()
　　
print(l)
　　
['dzm', 'alex', 'egon', 4, 5]
　　

　　下面这样复制列表只是将另一个名称关联到列表而已，copy才是指向不同的列表
　　a = [1, 2, 3]
　　b = a
　　#reverse 反转
　　

name_list=['dzm','alex','egon',4,5]　　
name_list.reverse()
　　
print(name_list)
　　
[5, 4, 'egon', 'alex', 'dzm']
　　

　　#sort排序，默认从小到大
　　

list=[2,4,3,1]　　
# list.sort()
　　
# print(list)
　　
# [1, 2, 3, 4]
　　
#从大到小
　　
# list.sort(reverse=True)
　　
# print(list)
　　
# [4, 3, 2, 1]
　　

　　sort修改不返回任何值

元组类型
　　#存多个值，有序，不可变，主要用来读
　　#优先掌握的操作
　　#按索引取值，只能取
　　#切片 顾头不顾尾，步长
　　

ages=(1,2,3,4)　　
# print(ages[0:2])
　　
# (1, 2)
　　

　　#长度
　　

ages=(1,2,3,4)　　
print(len(ages))
　　
4
　　

　　#成员运算 in 和 not in
　　

ages=('dzm',1,2,3,4)　　
print('dzm' in ages)
　　
True
　　

　　#其它操作
　　#index
　　

ages=('dzm',66,77,88,99)　　
print(ages.index(77))
　　
2
　　

　　#count
　　

ages=('dzm',66,77,88,99)　　
print(ages.count('dzm'))
　　
2
　　

字典类型
　　作用：存多个值,key-value存取，取值速度快
　　定义：key必须是不可变类型，value可以是任意类型
　　info={'name':'egon','age':18,'sex':'male'} #本质info=dict({....})
　　或
　　info=dict(name='egon',age=18,sex='male')

优先掌握的操作
　　1、按key存取值：可存可取
　　按key取值
　　

info={'name':'dzm','age':18,'sex':'male'}　　
print(input('name'))
　　
name
　　

　　存值
　　

info['hobbies']=['read','music']　　
print(info)
　　
{'name': 'dzm', 'age': 18, 'sex': 'male', 'hobbies': ['read', 'music']}
　　

　　2、长度len
　　统计key的数量
　　

info={'name':'dzm','age':18,'sex':'male'}　　
print(len(info))
　　
3
　　

　　3、成员运算in和not in
　　

info={'name':'dzm','age':18,'sex':'male'}　　
print('name' in info)
　　
True
　　
print(666 not in info)
　　
True
　　

　　需要掌握的字典的内置方法
　　4、删除
　　pop 将字典中key所对应的值从字典中取出来
　　

info={'name':'dzm','age':18,'sex':'male'}　　
print(info.pop('name'))
　　
print(info)
　　
dzm
　　
{'age': 18, 'sex': 'male'}
　　

　　指定默认值
　　pop所指定的key如果不存在怎会报错，这时可以指定默认值(一般用None)得方式避免报错
　　

print(info.pop('name123','没有这个key'))　　
没有这个key
　　

　　5、键keys()，值values()，键值对items()
　　info={'name':'dzm','age':18,'sex':'male'}
　　keys只取字典中的key
　　

print(info.keys())　　
dict_keys(['name', 'age', 'sex'])
　　

　　values只取字典中的values
　　

print(info.values())　　
dict_values(['dzm', 18, 'male'])
　　

　　可迭代类型，并不是列表类型
　　以上两种取值方法取出来的值可以在for循环中使用，for i in info.values()
　　举例
　　

for key in info.keys():　　print(key)
　　
name
　　
age
　　
sex
　　

　　items 将字典里的每对键值以元祖的形式取出来
　　

print(info.items())　　
dict_items([('name', 'dzm'), ('age', 18), ('sex', 'male')])
　　

　　几种用法举例
　　第一种
　　

for i in info.items():　　print(i)
　　
('name', 'dzm')
　　
('age', 18)
　　
('sex', 'male')
　　

　　第二种
　　

for i in info.items():　　print(i[0],i[1])
　　
name dzm
　　
age 18
　　
sex male
　　

　　第三种
　　

info={'name':'dzm','age':18,'sex':'male'}　　
for k,v in info.items():
　　print(k,v)
　　
name dzm
　　
age 18
　　
sex male
　　

需要掌握的方法
　　info={'name':'dzm','age':18,'sex':'male'}
　　get 取值
　　传统取值方式
　　print(info['name'])
　　get 取值方式如果没有这个key也不会报错，默认返货None，可以设置默认返回值
　　

print(info.get('name'))　　
dzm
　　

　　如果没有这个key也不会报错，默认返货None，可以设置默认返回值
　　

print(info.get('name123',123),)　　
123
　　

　　setdefault
　　如果字典中已经存在这个key了，则不修改
　　示例1
　　

info={'name':'dzm','age':18,'sex':'male'}　　
print(info.setdefault('age',19))
　　
18 #返回值为原字典中的值
　　

　　有则不改，返回已有的值，没有则新增，返回新增的值
　　示例2
　　

print(info.setdefault('hobbles',[]))　　
print(info)
　　
[]
　　
{'name': 'dzm', 'age': 18, 'sex': 'male', 'hobbles': []}
　　

　　示例3
　　

info.setdefault('hobbles',[]).append('music')　　
print(info)
　　
{'name': 'dzm', 'age': 18, 'sex': 'male', 'hobbles': ['music']}
　　

了解
　　clear
　　x和y最初都指向同一个字典，clear可以删除原来字典的所有元素，下面的例子中y也受到了影响，这和给x赋个空字典（x = {}）不同
　　

x = {}　　
y = x
　　
x['key'] = 'value'
　　
y
　　
{'key': 'value'}
　　
x.clear()
　　
y
　　
{}
　　

　　info.popitem()
　　popitem 直接删除并去除一对键值对，pop只会去除key
　　

info={'name':'dzm','age':18,'sex':'male'}　　
print(info.popitem())
　　
('sex', 'male')
　　

　　update 更新
　　

info={'name':'dzm','age':18,'sex':'male'}　　
info_new={'a':1,'age':19}
　　
语法：原字典.update(用于更新的字典)
　　
info.update(info_new)
　　
print(info)
　　
{'name': 'dzm', 'age': 19, 'sex': 'male', 'a': 1}
　　

　　通过上面的例子可以看出如果原字典没有这个key则将新的key和值加入到原来字典中
　　如果之前就有这个key，那么就更新这个key对应的value
　　.fromkeys() 创建一个空字典,并设置默认值
　　用法
　　

dic={}.fromkeys(['name','age','sex'],None)　　
print(dic)
　　
{'name': None, 'age': None, 'sex': None}
　　

集合
　　作用：去重，关系运算，
　　定义集合:
　　集合：可以包含多个元素，用逗号分割，
　　集合的元素遵循三个原则：
　　1：每个元素必须是不可变类型(可hash，可作为字典的key)
　　2: 没有重复的元素
　　3：无序
　　注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值
　　自动去重
　　

s={1,2,3,4,5,6,1,1,1}　　
print(s)
　　
{1, 2, 3, 4, 5, 6}
　　

　　# 优先掌握的操作：
　　1、长度len
　　

s={1,2,3,4,5,6,1,1,1}　　
print(len(s))
　　
6
　　

　　2、成员运算in和not in
　　

print(1 in s)　　
True
　　

　　3、|合集,并集(将两个集合合并，且去重)
　　

s1={1,2,3,4}　　
s2={4,5,6}
　　
s3=s1 | s2
　　
print(s3)
　　
{1, 2, 3, 4, 5, 6}
　　

　　4、&交集（取两个集合共有的值）
　　

s1={1,2,3,4}　　
s2={4,5,6}
　　
print(s1 & s2)
　　
{4}
　　

　　5、-差集(前者减去与后者共有的部分)
　　

s1={1,2,3,4}　　
s2={4,5,6}
　　
print(s1 - s2)
　　
{1, 2, 3}
　　

　　6、^对称差集（取两个集合共有部分之外的部分，合为一个集合）
　　

s1={1,2,3,4}　　
s2={4,5,6}
　　
print(s1 ^ s2)
　　
{1, 2, 3, 5, 6}
　　

　　7、==(判断值相不相等)
　　8、父集：>,>=（判断的是包含关系）
　　

s1={1,2,3,4}　　
s2={3,4}
　　
print(s1 > s2)
　　
True
　　

　　s1是s2的父集，s2是s1的子集
　　

print(s1 >= s2)　　
True
　　

　　9、子集：<,<=(跟上面相同)
　　#常用操作
　　#pop (随机删，并返回删除的值，类似剪切)
　　

# s1={1,2,3,'a',4}　　
# print(s1.pop())
　　
# 1
　　

　　#remove 指定元素删除，无返回值，单纯删除
　　#如果删除的元素不存在则报错
　　

# s1={1,2,3,'a',4}　　
# s1.remove('a')
　　
# print(s1)
　　
# {1, 2, 3, 4}
　　

　　#discard，删除，但没有返回值
　　#删除不存在的值不会报错，这是它与remove的区别
　　

# s1={1,2,3,'a',4}　　
# s1.discard('a')
　　
# print(s1)
　　
# {1, 2, 3, 4}
　　

　　#add 添加内容，无序
　　

# s1={1,2,3,'a',4}　　
# s1.add('b')
　　
# print(s1)
　　
# {1, 2, 3, 4, 'a', 'b'}
　　

　　#isdisjoint如果两个集合没有交集则返回Ture
　　

# s1={1,2,3,4}　　
# s2={5,6}
　　
# print(s1.isdisjoint(s2))
　　
# True
　　

文件处理
　　#默认是rt t就是text文本
　　

# f=open('1.txt',encoding='utf-8') #打开文件　　
# data=f.read() #发信号让操作系统读取文件
　　

# print(data)　　
# f.close()#文件关闭，回收操作系统资源
　　

　　#执行后
　　#你好啊
　　#open打开.txt文件后会报错，windows默认使用gbk打开文件，而文件是使用utf-8存储的
　　#下面的语句等于f=open('1.txt',encoding='utf-8')
　　#在操作结束后会自动关闭文件，不用再收入f.close()
　　

# with open('1.txt',encoding='utf-8') as f:　　
#     pass
　　

　　#文件打开后光标会自动在第一个字符前
　　#data=f.read()#读取全部内容，光标从头移动到了尾部
　　

# f=open('1.txt',encoding='utf-8')　　
# data1=f.read()
　　
# print('----1',data1)
　　
# data2=f.read()
　　
# print('----2',data2)
　　
# 结果：
　　
# ----1 你好啊
　　
# ----2
　　

　　#读操作 只读模式，默认是文本读
　　#readline读取一行
　　

# f=open('1.txt',encoding='utf-8')　　
# print(f.readline())
　　
# print(f.readline())
　　
# print(f.readline())
　　
#结果
　　
# aaaa
　　
#
　　
# bbbbb
　　
#
　　
# cccc
　　

　　#会发现多出了一行空行，这是print自带的换行功能
　　#使用end=''参数取消print的换行功能
　　

# print(f.readline(),end='')　　
# print(f.readline(),end='')
　　
# print(f.readline(),end='')
　　
#结果
　　
# aaaa
　　
# bbbbb
　　
# cccc
　　

　　#readlines把文件每一行都读取出来放到一个列表里去
　　

# f=open('1.txt',encoding='utf-8')　　
# print(f.readlines())
　　
# ['aaaa\n', 'bbbbb\n', 'cccc\n']
　　

　　#写操作 只写模式，默认是文本写
　　#如果文件不存在则创建，存在则覆盖
　　#文本方式打开只能往里面写字符，不能写数字
　　#write 写内容，需要自己写换行符
　　

# f=open('1.txt','w',encoding='utf-8')　　
# f.write('aaa\n')
　　
# f.write('bbb\n')
　　
# 或者
　　
# f.write('aaa\nbbb\nccc')
　　

　　#writelines
　　#以列表格式存入文本
　　

# f.writelines(['你好\n','你好啊'])　　
# f.close()