python之二 基础 一

• 本章节 主要内容

1. 列表, 元组
2. 字符串操作

       1. 列表，元组

　　 列表是最常用的数据类型之一，通过列表可以对数据实现最方便的存储，修改等操作

　　 定义列表

　　name = [ 'zhansan','lisi','wangwu' ]   列表使用的是[ ]中括号 可以增删该差 但是元组不能 ，

通过下标访问列表中的元素，下标从0开始计数
 
 >>> name[0]
 'zhangsan'
 
 >>> name[1]
 'lisi'
 >>> name[2]
 'wangwu'
 
 >>> name[0:1] #下面这些在去下标的时候 顾首不顾尾
 ['zhangsan']
 >>> name[0:2]
 ['zhangsan', 'lisi']
 >>> name[0:3]
 ['zhangsan', 'lisi', 'wangwu']
 
 这些就称为下标
 
 切片:取多个元素
 >>> name = ['zhangsan','lisi','wangwu','zhaoliu','xiaoqi','xiaojiu']
 >>> name[1:4]
 ['lisi', 'wangwu', 'zhaoliu']   #取下标1至下标4之间的数字，包括1，不包括4
 >>>
>>> name[1:-1]
['lisi', 'wangwu', 'zhaoliu', 'xiaoqi'] #取下标1至-1的值，不包括-1
>>>
>>> name[0:3]
['zhangsan', 'lisi', 'wangwu']
>>>
>>> name[:3]
['zhangsan', 'lisi', 'wangwu']  #如果是从头开始取，0可以忽略，跟上句效果一样

>>> name[3:]
['zhaoliu', 'xiaoqi', 'xiaojiu']  #如果想取到最后可以这样写

>>> name[0::2]
['zhangsan', 'wangwu', 'xiaoqi'] #后面的2 代表，每隔一个元素，就取一个
>>> name[::2]
['zhangsan', 'wangwu', 'xiaoqi']

　　追加

>>> name
['zhangsan', 'lisi', 'wangwu', 'zhaoliu', 'xiaoqi', 'xiaojiu']
>>> name.append("add")  #会把add添加到列表的后面
>>> name
['zhangsan', 'lisi', 'wangwu', 'zhaoliu', 'xiaoqi', 'xiaojiu', 'add']

　 插入

>>> name
['zhangsan', 'lisi', 'wangwu', 'zhaoliu', 'xiaoqi', 'xiaojiu', 'add']

name.insert(2,"insert") #把inster添加到 wangwu前面

>>> name
['zhangsan', 'lisi', 'inster', 'wangwu', 'zhaoliu', 'xiaoqi', 'xiaojiu', 'add']

 

　　修改

>>> name
['zhangsan', 'lisi', 'inster', 'wangwu', 'zhaoliu', 'xiaoqi', 'xiaojiu', 'add']
>>> name[1]="wang" #把lisi改成wang
>>> name
['zhangsan', 'wang', 'inster', 'wangwu', 'zhaoliu', 'xiaoqi', 'xiaojiu', 'add']

 

　　删除  #删除有三种操作 del， remoce删除指定元素 ， pop 删除列表最后一个

>>> name
['zhangsan', 'wang', 'inster', 'wangwu', 'zhaoliu', 'xiaoqi', 'xiaojiu', 'add']
>>> del name[3]
>>> name
['zhangsan', 'wang', 'inster', 'zhaoliu', 'xiaoqi', 'xiaojiu', 'add']
>>> name.remove("wang")
>>> name
['zhangsan', 'inster', 'zhaoliu', 'xiaoqi', 'xiaojiu', 'add']
>>> name.pop()
'add'
>>> name
['zhangsan', 'inster', 'zhaoliu', 'xiaoqi', 'xiaojiu']

 

　　扩展

>>> name   
['zhangsan', 'inster', 'zhaoliu', 'xiaoqi', 'xiaojiu']
>>> age=[22,33,44]
>>> name.extend(age) #extemd用于扩展
>>> name
['zhangsan', 'inster', 'zhaoliu', 'xiaoqi', 'xiaojiu', 22, 33, 44]

 

　　拷贝

>>> name
['zhangsan', 'inster', 'zhaoliu', 'xiaoqi', 'xiaojiu', 22, 33, 44]
>>>
>>> name_copy = name.copy() #name.copy 浅拷贝 只能拷贝一层
>>> name_copy
['zhangsan', 'inster', 'zhaoliu', 'xiaoqi', 'xiaojiu', 22, 33, 44]

　　统计

>>> name
['zhangsan', 'inster', 'zhaoliu', 'xiaoqi', 'xiaojiu', 22, 33, 44]
>>> name.insert(2,"xiaoqi") #统计列表里面xiaoqi出现的次数
>>> name
['zhangsan', 'inster', 'xiaoqi', 'zhaoliu', 'xiaoqi', 'xiaojiu', 22, 33, 44]
>>> name.count("xiaoqi")
2

　　排序和反转

>>> name = ['zhangsan','lisi','wangwu','1','2','3']
>>> name.sort()
>>> name
['1', '2', '3', 'lisi', 'wangwu', 'zhangsan']
>>>
>>> name.reverse()
>>> name
['zhangsan', 'wangwu', 'lisi', '3', '2', '1']

 

　　获取下标

>>> name
['zhangsan', 'wangwu', 'lisi', '3', '2', '1']

>>> name.index('wangwu')
1

 元组

元组其实跟列表差不多，也是存一组数，只不是它一旦创建，便不能再修改，所以又叫只读列表

语法

name=('zhansan','lisi','wangwu')

它只有2个方法，一个是count,一个是index，

 

  2,字符串操作

>>> my = "my love is eat"
>>> print(my.capitalize()) #首字母大写
My love is eat

>>> print(my.count("a")) #统计有几个a
1

>>> print(my.endswith("at")) #以什么结尾
True


------------------my love is eat------------------

 

>>> print(my.find("love")) #切片
3

 

 my2 = "my name is {name} and i am {year} old "
>>> print(my2.format(name='hello',year=22))  #格式化 
my name is nicai and i am 22 old

>>> print(my2.format_map( {'name':'hello','year':22 } ))  同上  大部分用上面那个
my name is hello and i am 22 old

——————————————————————————————————————

>>> print('123asd'.isalnum()) #有阿里伯数字的显示True
True

>>> print('123asd'.isalpha()) #纯英文字符就显示True 否则 False
False

 print('12'.isdigit()) #是否是为整数
True

>>> print('a1A'.isidentifier()) ##标识符 判断是不是一个合格的表示符 是不是一个合法的变量名
True

>>> print('33'.isnumeric()) #只有数字在里面的时候返回True 小数不行
True

>>> print(' '.isspace()) #是否是空格
True

>>> print('My Name Is'.istitle())#是否为title 首字母大写
True

>>> print('My Name Is'.isupper())#是否全是大写
False

——————————————————————————————————————————————

 

>>> print(''.join(['1','2','3']))
123
>>> print(','.join(['1','2','3']))
1,2,3

>>> print('+'.join(['1','2','3']))
1+2+3

 

——————————————————————————————————————————————

>>> name = "my name is"
>>> print(name.ljust(50,'*'))
my name is****************************************
>>> print(name.rjust(50,'-'))
----------------------------------------my name is

 

————————————————————————————————————————————

>>> print('Name'.lower())#把大写变小写
name
>>> print('Name'.upper())#把小写变大写
NAME

>>> print(' love\n'.lstrip()) #从左边去除空格和者回车
love

>>> print(' love\n'.rstrip())#从右边去除空格和者回车
 love

>>> print('    love\n'.strip()) #两边去除空格和回车 一般这个用的多
love

>>> print('love ll '.replace('l','L')) 把 l 全部替换 L
Love LL
>>> print('love ll '.replace('l','L',1))  只替换一个
Love ll

>>> print('love me'.rfind('e'))  #从左往右 找到最右边的下标
6

>>> print('love me'.rfind('me'))  
5

>>> print('lo ve is '.split())#默认按照空格来分成一个列表
['lo', 've', 'is']

>>> print('lo ve is '.split('l')) 按照 l 分割
['', 'o ve is ']

>>> print('1+2+3+4'.split('+'))
['1', '2', '3', '4']
>>> print('1+2+\n3+4'.splitlines())
['1+2+', '3+4']

>>> print('Love Is'.swapcase())
lOVE iS

>>> print('Love Is'.title())
Love Is

>>> print('love'.zfill(10))
000000love

 

•  字典操作
• 集合操作
• 文件操作
• 字符编码与转码

　　3. 字典操作

字典一种key - value 的数据类型，使用就像我们上学用的字典，通过笔划、字母来查对应页的详细内容。

字段的特性

  dict是无序的

  key必须是唯一的，所以天生去重

语法

info = {
    'stu01' : "zhang",
    'stu02' : "wang",
    'stu03' : "li",
}

print(info)


　

　　增加
>>> print(info)
{'stu03': 'li', 'stu01': 'zhang', 'stu02': 'wang'}
>>> info["stu04"] = "zhao"
>>> print(info)
{'stu03': 'li', 'stu01': 'zhang', 'stu02': 'wang', 'stu04': 'zhao'}
　　　 
　　　修改
>>> info["stu03"] = "liu"
>>> print(info)
{'stu03': 'liu', 'stu01': 'zhang', 'stu02': 'wang', 'stu04': 'zhao'}

　　　查找
>>> "stu01" in info  #标准用法
True
>>> info.get("stu02") #获取
'wang'
>>> info["stu03"] # 同上 但是
'liu'
>>> info["stu05"]    如果一个可以不存在，就会显示错误
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'stu05'

　　　　删除
>>> del info["stu01"] #删除
>>> info
{'stu03': 'liu', 'stu02': 'wang', 'stu04': 'zhao'}

>>> info.pop("stu03") #标准删除
'liu'
>>> info
{'stu02': 'wang', 'stu04': 'zhao'}

>>> info
{'stu03': 'li', 'stu01': 'zhang', 'stu02': 'wang'}
>>> info.popitem("stu03") #不能这样删除 

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: popitem() takes no arguments (1 given)

>>> info.popitem() #是随机的不常用
('stu03', 'li')
>>> info.popitem()
('stu01', 'zhang')
>>> info
{'stu02': 'wang'}


　　多级字典嵌套及操作
info = {
    '北京':{
        '昌平':'a123',
        '三里屯':'b123',
        '不知道了':'c123'
    } ,
    '上海': {
        "浦东":"d123",
        "黄埔":"e123",
        "没了":"f123"
    },
    '河北':{
        
     '邯郸':'g123',
    '石家庄':'h123'
    }
}

>>> info
{'北京': {'三里屯': 'b123', '不知道了': 'c123', '昌平': 'a123'}, '河北': {'石家庄': 'h123', '邯郸': 'g123'}, '上海': {'浦 东': 'd123', '黄埔': 'e123', '没了': 'f123'}}
>>> info['河北']['邯郸']
'g123'

values
>>> info
{'北京': '昌平', '河北': '石家庄', '上海': '浦东'}
>>> info.values()
dict_values(['昌平', '石家庄', '浦东'])

keys
>>> info.keys()
dict_keys(['北京', '河北', '上海'])


update
>>> info
{'北京': '昌平', '河北': '石家庄', '上海': '浦东'}

>>> b = {1:2,3:4,"hello":"world"}
>>> b
{1: 2, 3: 4, 'hello': 'world'}
>>> info.update(b)
>>> info
{1: 2, 3: 4, 'hello': 'world', '上海': '浦东', '北京': '昌平', '河北': '石家庄'}


item
>>> info.items()
dict_items([(1, 2), (3, 4), ('hello', 'world'), ('上海', '浦东'), ('北京', '昌平'), ('河北', '石家庄')])
>>>

循环dic
方法一
info = {
    '北京':"昌平",
    '上海':"浦东",
    '河北':"石家庄"
}
for key in info:   #这个常用
    print(key,info[key])

for k,v in info.items(): #把一个字典变成列表 循环的时候第一个是k，第二个是v 处理大数据时不用这个方法
    print(k,v)

　　

　　4.集合操作
集合是一个无序的，不重复的数据组合，它的主要作用如下 
去重，把一个列表变成集合，就自动去重了
关系测试，测试两组数据之前的交集、差集、并集等关系

常用操作

>>> s = set([3,5,6,10])
>>> t = set("Hello")
>>> a = t|s
>>> print(a)
{'e', 3, 5, 6, 10, 'l', 'o', 'h'}
>>> b = t & s
>>> print (b)
set()
>>> c = t ^ s
>>> print (c)
{'e', 3, 5, 6, 10, 'l', 'o', 'h'}
>>> d = t - s
>>> print (d)
{'e', 'o', 'h', 'l'}


基本操作

>>> s = set([3,5,6,10])
>>> t = set("Hello")

>>> t.add('x')# 添加一项
>>> print(t)
{'e', 'x', 'o', 'H', 'l'}

>>> s.update([10,37,42])#添加多项
>>> print(s)
{3, 37, 5, 6, 10, 42}

>>> t.remove('H')
>>> print(t)
{'e', 'x', 'o', 'l'}

len(s)  
set 的长度  
6
x in s  
测试 x 是否是 s 的成员  
  
x not in s  
测试 x 是否不是 s 的成员  
  
s.issubset(t)  
s <= t  
测试是否 s 中的每一个元素都在 t 中  
  
s.issuperset(t)  
s >= t  
测试是否 t 中的每一个元素都在 s 中  
  
s.union(t)  
s | t  
返回一个新的 set 包含 s 和 t 中的每一个元素  
  
s.intersection(t)  
s & t  
返回一个新的 set 包含 s 和 t 中的公共元素  
  
s.difference(t)  
s - t  
返回一个新的 set 包含 s 中有但是 t 中没有的元素  
  
s.symmetric_difference(t)  
s ^ t  
返回一个新的 set 包含 s 和 t 中不重复的元素  
  
s.copy()  
返回 set “s”的一个浅复制

 

1.集合add的使用
s1 = {11,22,33,44,55,}
s1.add(123)
print(s1)
程序运行结果如下：
{33, 11, 44, 22, 55, 123}
 
2.集合difference的使用
s1 = {11,22,33,44,55,}
s2 = {11,22,33,44,}
s = s1.difference(s2)
print(s)
print(s1)
print(s2)
 
程序运行结果如下：
{55}
{33, 11, 44, 22, 55}
{33, 11, 44, 22}
从输出结果可以看出difference不会修改s1 s2集合本身
 
3.集合difference_update的使用
s1 = {11,22,33,44,55}
s2 = {11,22,33,44}
s3 = s1.difference_update(s2)
print(s3)
print(s1)
print(s2)
 
程序运行结果如下：
None
{55}
{33, 11, 44, 22}
从输出结果可以看出集合s1已经被修改
 
4.集合discard的使用
discard:删除集合中指定的元素
s1 = {11,22,33,44,55}
s1.discard(11)
print(s1)
 
程序运行结果如下：
{22,33,44,55}
 
第二种情况：移除集合中不存在的元素(即便元素不存在也不会报错)
s1 = {11,22,33,44,55,}
s1.discard(88)
print(s1)
程序运行结果如下：
{33, 11, 44, 22, 55}
 
5.集合clear的使用
clear:清空集合中所有的元素
 
s1 = {11,22,33,44,55,}
s1.clear()
print(s1)
 
程序运行结果如下：
set()
 
6.集合pop的使用
s1 = {11,22,33,44,55,}
s1.pop()
print(s1)
 
程序运行结果如下：
{11, 44, 22, 55}
 
7.集合remove的使用
 
s1 = {11,22,33,44,55,}
s1.remove(44)
print(s1)
 
程序运行结果如下：
{33, 11, 22, 55}
 
 
如果元素不在集合中，则会报错
s1 = {11,22,33,44,55,}
s1.remove(66)
print(s1)
 
报错信息如下
Traceback (most recent call last):
  File "D:/PythonS13/day3/test.py", line 34, in <module>
    s1.remove(66)
KeyError: 66
 
8.集合intersection的使用
s1 = {11,22,33,44,55}
s2 = {11,22,33,44}
s3 = s1.intersection(s2)
print(s3)
 
程序运行结果如下：
{33, 11, 44, 22}
 
9.集合intersection_update的使用
s1 = {11,22,33,44,55}
s2 = {11,22,33,44}
s1.intersection_update(s2)
print(s1)
 
 
10.集合isdisjoint的使用
s1 = {11,22,33,44,55}
s2 = {11,22,33,44}
s3 = {66,77,88}
s4 = s1.isdisjoint(s2)
s5 = s1.isdisjoint(s3)
print(s4)
print(s5)
 
程序运行结果如下：
False
True
 
11.集合issubset和issuperset的使用
s1 = {11,22,33,44,55}
s2 = {11,22,33,44}
s3 = {66,77,88}
s4 = s2.issubset(s1)
s5 = s1.issuperset(s2)
print(s4)
print(s5)
 
程序运行结果如下：
True
True

 

　　3 文件操作

对文件操作流程

打开文件，得到文件句柄并赋值给一个变量

通过句柄对文件进行操作

关闭文件

 

#f = open('file',encoding="utf-8").read()#打开一个文件 不符合正常的编写规范

f = open('file',encoding="utf-8")#会付给f一个内存对象 也可以叫做文件句柄

#句柄包含文件的文件名，字符集，大小，内存，还有硬盘上的起始位置 就可以读写了

data = f.read()

#在打印第一遍时 从头打印到尾，当在打印第二遍的时候 就直接从尾部开始打印了 所以打引不出来东西

data2 = f.read()

print('data')

print('---------data2-------------'，data2)

f = open('file','w',encoding="utf-8") #默认创建一个新文件
f.write("my heart go on,\n") #这样就能写了
f.write(" go on")
#但是 写的模式打开就不能读了 但是如果又想读又想写 可以用a=append 追加
f = open('file','a',encoding="utf-8") #默认创建一个新文件
f.write("my heart go on,\n") 
f.write(" go on")
# 这样可以一行一行的读  #如果要是打印多行的话 这种方法就显得微不足道了
f = open('file','r',encoding="utf-8")
print(f.readline())#f.readline的意思是一行
如果要是打印多行的话

所以可以这样
f = open('file','r',encoding="utf-8")
for in in range(5):
　　print(f.readline())

除了上面那个还有一个优化的那就是用f.readlines 它的作用就是把文件里面的内容变成列表 ，每一行就是一个元素
格式如下
['************\n','*********\n'
这样就可以使用下面的循环了
f = open('file','r',encoding="utf-8")
print(f.readline())#f.readline的意思是一行
for index,line in enumerate(f.readlines()):
    if index == 9:
        print('-----这是第十行-------')
        continue
    print(line.strip())
#readlines只能使用一小文件 因为他要把文件的所有行读到内存里 显然是处理不了的

为了解决这些问题 可以采用 让他读一行执行一行，读一行执行一行
例子 

f = open('file','r',encoding="utf-8")
count =0
for line in f:
    if count == 9:
        print('--------第十行----------')
        count += 1
        continue
    print(line)
    count +=1

打开文件的模式有：
    r，只读模式（默认）。
    w，只写模式。【不可读；不存在则创建；存在则删除内容；】
    a，追加模式。【可读；   不存在则创建；存在则只追加内容；】
"+" 表示可以同时读写某个文件
    r+，可读写文件。【可读；可写；可追加】
    w+，写读
    a+，同a
"U"表示在读取时，可以将 \r \n \r\n自动转换成 \n （与 r 或 r+ 模式同使用）
    rU
    r+U
"b"表示处理二进制文件（如：FTP发送上传ISO镜像文件，linux可忽略，windows处理二进制文件时需标注）
    rb
    wb
    ab