Python正式课第四天

作者: code与有荣焉 | 来源:发表于2019-11-07 21:29 被阅读0次

一、列表（补充）

切片

对序列截取一部分的操作
字符串、列表、元组都支持切片操作
格式：

格式：对象[start:end:step] 左闭右开 省略 start代表从零开始，end代表包括最后，步长省略代表1

示例：

# -*- coding: utf-8 -*-
# @Time    : 2019/11/7 8:56
# @Author  : Han lei
# @Email   : hanlei5012@163.com
# @File    : demo13.py
# @Software: PyCharm
# 切片
# 对序列截取一部分的操作
# 字符串、列表、元组都支持切片操作
l1 = [i for i in range(10)]
print(l1)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(l1[2])  # 2
# 格式：对象[start:end:step] 左闭右开 省略 start代表从零开始，end代表包括最后，步长省略代表1
print(l1[2:7])  # [2, 3, 4, 5, 6]
print(l1[2:])  # [2,3,4,5,6,7,8,9]
print(l1[0:4:2])  # [0,2]
print(l1[0:-2])  # [0,1,2,3,4,5,6,7]
print(l1[-4:-2])  # [6,7]
print(l1[-4:2])  # []
print(l1[-1:-3:-1])  # [9,8]
print(l1[-1:1:-1])  # [9,8,7,6,5,4,3,2]
print(l1[3:1:-1])  # [3,2]
print(l1[3:-3:-1])  # []
print(l1[::])  # [0,1,2,3,4,5,6,7,8,9]
print(l1[:])  # [0,1,2,3,4,5,6,7,8,9]
print(l1[::2])  # [0，2，4，6，8]

反转这个列表

print(l1[::-1])  # [9,8,7,6,5,4,3,2,1,0]

使用切片来原地修改列表的内容

a = [3, 5, 7]
a[len(a):] = [9]
print(a)  # [3, 5, 7, 9]

a[:3] = [1, 2, 3]
print(a)  # [1, 2, 3, 9]

a[:3] = []
print(a)  # [9]

使用del 和切片结合删除列表的元素

a = [3, 5, 7, 9, 11]
del a[:3]  # [9, 11]
print(a)
del a[::2]
print(a)  # [5, 9]

浅复制

是指生成了一个新的列表，并且把原列表中所有元素的引用都复制到这个新的列表中

# 浅复制，是指生成了一个新的列表，并且把原列表中所有元素的引用都复制到这个新的列表中

aList = [3, 5, 7]
bList = aList  # bList与aList指向同一内存
print(id(aList))  # 2247256
print(id(bList))  # 2247256

bList[1] = 8
print(aList)  # [3, 8, 7]
print(id(aList))  # 2247256
print(id(bList))  # 2247256

print(aList == bList)  # == 是判断两个列表中的元素是否完全一样
print(aList is bList)  # is 判断两个列表是否是同一个对象

aList = [3, 5, 7]
bList = aList[::]  # 切片 浅复制
print(bList == bList)  # True
print(aList is bList)  # False
print(id(aList))  # 2377168
print(id(bList))  # 2378328
bList[1] = 8
print(bList)  # [3, 8, 7]
print(aList)  # [3, 5, 7]

# 结论 切片返回的是列表的元素的浅复制
# id() 查看元素的内存地址
# == 是判断两个列表中的元素是否完全一样
# is 判断两个列表是否是同一个对象

结论：切片返回的是列表的元素的浅复制

二、元组 tuple

元组属于不可变的序列，一旦创建，用任何方法都不能将其修改 ()表示

# 元组属于不可变的序列，一旦创建，用任何方法都不能将其修改 ()表示
a = (1, 2, 3)
print(type(a))  # <class 'tuple'>
# 一个元素的元组
x = (3)
print(type(x))  # <class 'int'>
x = (3, )
print(type(x))  # <class 'tuple'>

使用tuple函数将其他的序列转化为元组

1. 列表转化成元组

from random import randint
a = [randint(-10, 10) for _ in range(10)]
print(a)  # [-5, -10, -8, 0, -10, 4, -8, 8, 10, -7]
a_tuple = tuple(a)
print(a_tuple)  # (-5, -10, -8, 0, -10, 4, -8, 8, 10, -7)

2. range函数

print(list(range(6)))  # [0, 1, 2, 3, 4, 5]
print(tuple(range(6)))  # (0, 1, 2, 3, 4, 5)

3. 字符串

import string
print(string.ascii_lowercase[:7])  # abcdefg
t = tuple(string.ascii_lowercase[:7])
print(t)  # ('a', 'b', 'c', 'd', 'e', 'f', 'g')

元组和列表的区别

元组中数据一旦定义就不允许修改了
元组中没有 append()、extend()、insert()等方法，不能向元组中添加元素
元组中也没有删除相关方法，不能从元组中删除元素
从效果上看，tuple函数是冻结列表，list函数是融化列表

元组优点

元组的速度要比列表快
元组对数据进行‘写保护’，让代码更加安全
元组可以用作字典的键，还可以作为函数的返回值返回（返回多个值）

三、字符串

字符串的切片

# 字符串的切片
import string
letters = string.ascii_uppercase[:9]
print(letters)  # ABCDEFGHI
print(letters[3])  # D
print(letters[2:4])  # CD
print(letters[:])  # 默认返回整个字符串，不过这是个浅复制
print(letters[-2:])  # HI
print('letters[-2:2]', letters[-2:2])  # letters[-2:2]
print(letters[::-1])  # IHGFEDCBA

字符串常用操作方法

upper()、lower()
常用指数***

# 1. upper()、lower() 常用指数***
s1 = 'www.NEUEDU.com'
print(s1.upper())  # 全部大写  # WWW.NEUEDU.COM
print(s1.lower())  # 全部小写  # www.neuedu.com

startswith endswith
常用指数***

# 2. startswith endswith 常用指数***
s1 = 'www.wwwNEUEDU.com'
print(s1.startswith('www'))  # 判断是否以prefix开头 # True
print(s1.startswith('www', 4, 6))  # False  # 左闭右开
print(s1.endswith('.com'))  # 判断是否以suffix结尾 # True

查找元素 find() index() 、 rfind() rindex() 获取指定元素首次出现的下标
常用指数****

# 3. 查找元素 find() index() 、 rfind() rindex()  常用指数****
#获取指定元素首次出现的下标
s1 = 'www.wwwNEUEDU.com'
print(s1.find('N'))  # 7
print(s1.index('N'))  # 7
print(s1.find('F'))  # -1 # find找不到返回-1
# print(s1.index('F'))  # index 找不到这个子串会报错

print(s1.rfind('w'))  # 6 # 获取指定元素首次出现的下标,只不过是从右面开始
print(s1.rindex('w'))

strip 默认取出字符串前后两端的空格，换行，tab
常用指数*****

# 4. strip 默认取出字符串前后两端的空格，换行，tab  常用指数*****
rstrip lstrip
s1 = '   \n www.wwwNEUEDU.com\t   '
print(len(s1))   # 26
print(len(s1.strip()))  # 26
print(s1.strip())   # www.wwwNEUEDU.com
s2 = 'aabbccddff'
s2 = s2.strip('aa')  # 指定参数取出
print(s2)  # bbccddff
s2 = s2.rstrip('ff')  # 指定为右端
print(s2)  # aabbccdd
s2 = s2.lstrip('ff')  # 指定为左端
print(s2)  # aabbccddff

split 把字符串分隔成列表默认是以空格进行分隔
常用指数*****

# 5. split 把字符串分隔成列表 默认是以空格进行分隔  常用指数*****
s1 = 'life is short, use Python'
print(s1.split())  # 默认是以空格进行分隔 # ['life', 'is', 'short,', 'use', 'Python']
print(s1.split(','))  # ['life is short', ' use Python']
s2 = 'life ;is ;short, ;use ;Python'
print(s2.split(';', 3))  # 指定分隔几次  # ['life ', 'is ', 'short, ', 'use ;Python']
s2 = 'wwNEUw.\nwwwNEUEDU.com'  # 按照行分隔，返回包含按照各行分隔为元素的列表
s2 = s2.splitlines()
print(s2) ['wwNEUw.', 'wwwNEUEDU.com']

join 把列表转换成字符串
常用指数*****

# 6. join 把列表转换成字符串  常用指数*****
s1 = 'life is short use Python'
l1 = s1.split()
print(l1)  # l1里面的元素必须全是字符串 # ['life', 'is', 'short', 'use', 'Python']
s2 = ''.join(l1)
print(s2)  # lifeisshortusePython
s3 = ' '.join(l1)
print(s3)  # life is short use Python
s4 = '_'.join(l1)
print(s4)  # life_is_short_use_Python
s5 = '/'.join(l1)
print(s5)  # life/is/short/use/Python
s6 = '\\ '.join(l1)
print(s6)  # life\ is\ short\ use\ Python

is 系列
常用指数***

# 7. is 系列  常用指数***
name = 'Neusoft123'
print(name.isalnum())  # 所有的字符串是否是数字或者字母 # True
print(name.isdigit())  # 所有的字符串是否是数字 # False
print(name.isalpha())  # 所有的字符串是否是字母 # False
print(name.islower())  # 所有的字符串是否是小写 # False
print(name.isupper())  # 所有的字符串是否是大写 # False
print(name.istitle())  # 所有的字符串是否是首字母大写 # True
print(name.isspace())  # 所有的字符串是否是空白字符 # False

count 计算某个字符串出现的次数
常用指数****

# 8. count 计算某个字符串出现的次数  常用指数****
name = 'Neusoft1233'
print(name.count('3'))  # 2

replace 替换指定的字符
常用指数*****

# 9. replace 替换指定的字符  常用指数*****
name = 'Neusoft1233'
name = name.replace('1233', '')
print(name)  # Neusoft
name = '1233Neusoft1233'
name = name.replace('1233', '', 1)
print(name)  # Neusoft1233

首字母大写
常用指数**

# 10. 首字母大写  常用指数**
name = 'neusoft1233'
print(name.capitalize())  # Neusoft1233

center 将字符串居中
参数可以设置字符串的总长度，可以使用进行填充
ljust 左对齐 rjust 右对齐
常用指数

# 11. center 将字符串居中  常用指数*
# 参数可以设置字符串的总长度，可以使用*进行填充
name = 'neusoft1233'
print(name.center(100, '*'))  # 一共的长度是100 # ********************************************neusoft1233*********************************************
# ljust 左对齐 rjust 右对齐
s1 = 'neuedu'
print(len(s1))  # 6
print(s1.ljust(20))  # neuedu
print(s1.rjust(20))  #               neuedu
print(len(s1.ljust(20)))  # 20
print(s1.ljust(20, '*'))  # neuedu**************

title
非字母隔开的每个单词的首字母大写
常用指数*

# 12. title
# 非字母隔开的每个单词的首字母大写  常用指数*
s = 'chen wuang4fhsa￥fh。f'
print(s.title())  # Chen Wuang4Fhsa￥Fh。F

partition 将字符串分成三部分

# 13. partition 将字符串分成三部分
s1 = 'wwNEUw.wwwNEUEDU.com'
print(s1.partition('NEU'))  # 返回的是元组 # ('ww', 'NEU', 'w.wwwNEUEDU.com')
print(s1.rpartition('NEU'))  # ('wwNEUw.www', 'NEU', 'EDU.com')

四、字典

包含若干键值对的无序可变的序列，字典中的键可以为任意的不可变的数据，比如number、string、tuple
示例：

# 创建字典
import string
d = {'server': 'db.neuedu.com', 'database': 'oracle'}
print(type(d))  # <class 'dict'>
print(d)
# 空字典
d1 = {}
d2 = dict()
print('d2', d2)
print(type(d1))  # <class 'dict'>

使用dict函数将已有数据转化成字典

两个列表

# 1. 两个列表
keys = [x for x in string.ascii_lowercase[:5]]
print(keys)  # ['a', 'b', 'c', 'd', 'e']
values = [i for i in range(1, 6)]
print(values)  # [1, 2, 3, 4, 5]
print(dict(zip(keys, values)))  # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}

使用dict() 根据给定的键值创建

# 2. 使用dict() 根据给定的键值创建
d3 = dict(name='wunan', age=18, gender='female')
print('d3', d3)  # d3 {'name': 'wunan', 'age': 18, 'gender': 'female'}

根据给定的内容为键、创建值为空的字典

# 3. 根据给定的内容为键、创建值为空的字典
print(dict.fromkeys(['name', 'age', 'gender']))  # {'name': None, 'age': None, 'gender': None}

字典的读取

格式：字典名['键']

# 字典的读取
# 字典名['键']
print(d3['name'])  # wunan
# print(d3['addr'])  # 以键作为下标读取字典元素，不存在这个键就会抛出异常
# 解决办法： 使用字典的get方法获取指定键对应的值，并且可以为不存在的键指定默认返回值
print('*'*50)
print(d3.get('name'))  # wunan
print(d3.get('addr', '内蒙古通辽'))  # 内蒙古通辽

print('*'*50)
# 获取字典所有键 返回包含这个字典所有键的列表
print(list(d3.keys()))  # ['name', 'age', 'gender']
# 获取字典所有的值 返回包含这个字典所有值的列表
print(list(d3.values()))  # ['wunan', 18, 'female']
# 获取字典所有的键、值
print(list(d3.items()))  # [('name', 'wunan'), ('age', 18), ('gender', 'female')]
d4 = dict(list(d3.items()))
print(d4)  # {'name': 'wunan', 'age': 18, 'gender': 'female'}

print('*'*50)

字典的修改

格式：字典名['键'] = '新的值'

# 字典的修改
print('d3', d3)  # d3 {'name': 'wunan', 'age': 18, 'gender': 'female'}
# 字典名['键'] = '新的值'
d3['gender'] = 'male'
print(d3)  # {'name': 'wunan', 'age': 18, 'gender': 'male'}

字典的添加

格式：字典名['字典中不存在的键']='新的值'

当字典中存在这个键进行赋值时是修改操作
当字典中不存在这个键进行赋值时是添加操作

# 字典的添加
# 字典名['字典中不存在的键']='新的值'
# 当字典中存在这个键进行赋值时是修改操作
# 当字典中不存在这个键进行赋值时是添加操作
d3['addr'] = '沈阳市浑南区新秀街'
print(d3)  # {'name': 'wunan', 'age': 18, 'gender': 'male', 'addr': '沈阳市浑南区新秀街'}

字典的删除

del 可以删除整个字典，或者其中的某个指定元素

# 1. del 可以删除整个字典，或者其中的某个指定元素
print(d3)  # {'name': 'wunan', 'age': 18, 'gender': 'male', 'addr': '沈阳市浑南区新秀街'}
del d3 # 字典完全被删除
根据键删除整个元素
del d3['addr']
print(d3)  # {'name': 'wunan', 'age': 18, 'gender': 'male'}

清除字典的所有数据

# 2. 清除字典的所有数据
d3.clear()
print(d3)  # {}

pop # 删除指定键所对应的值，返回这个值并且从字典中把他移除

# 3. pop # 删除指定键所对应的值，返回这个值并且从字典中把他移除
ret = d3.pop('addr')
print(ret)  # 沈阳市浑南区新秀街
print(d3)  # {'name': 'wunan', 'age': 18, 'gender': 'male'}

按照后进先出的顺序返回并删除字典的最后的键值对

# 按照后进先出的顺序返回并删除字典的最后的键值对
a = d3.popitem()
print(a)  # ('addr', '沈阳市浑南区新秀街')
print(d3)  #{'name': 'wunan', 'age': 18, 'gender': 'male'}

判断一个key 是否在字典中

# 判断一个key 是否在字典中
print('name' in d3.keys())  # True
print('name' in d3)  # True

字典的遍历

# 字典的遍历
# 遍历所有的键
for k in d3.keys():
    print(k)
# 遍历所有的值
for v in d3.values():
    print(v)
# 遍历所有的项
for kv in d3.items():
    print(kv)  # 元组
"""
('name', 'wunan')
('age', 18)
('gender', 'male')
('addr', '沈阳市浑南区新秀街')
"""
# 遍历字典所有键值
for k, v in d3.items():
    print(k, '--->', v)
"""
name ---> wunan
age ---> 18
gender ---> male
addr ---> 沈阳市浑南区新秀街
"""

有序字典

可以使用collection模块的

# 有序字典 可以使用collection模块的
from collections import OrderedDict
# 创建一个无序字典
x = {}
x['b'] = 3
x['a'] = 1
x['c'] = 5
print(x)  # {'b': 3, 'a': 1, 'c': 5}
# 创建有序字典
x = OrderedDict()
x['b'] = 3
x['a'] = 1
x['c'] = 5
print(dict(x))

字典推导式（字典解析）

格式：

# 字典推导式 （字典解析）
[i for i in range(10)]
{k:v for 临时变量 in 迭代对象 if 条件}

示例1：使用字典解析筛选大于60分成绩的学生

from random import randint
# {'student1':90,'student2':90,'student3':90} 20 名学生
grade = {'student{}'.format(x): randint(0, 100) for x in range(1, 11)}
print(grade)  # {'student1': 26, 'student2': 17, 'student3': 31, 'student4': 96, ...}

# 使用字典解析筛选 大于60分成绩的学生
jige = {}
for k, v in grade.items():
    if v > 60:
        jige[k] = v
print(jige)

jige = {k: v for k, v in grade.items() if v>60}
print(jige)

示例2：用字典推导式以字符串以及其索引位置建字典

# 用字典推导式以字符串以及其索引位置建字典
strings = ['import','is','with','if','file','exception','liuhu']
print([(index, v) for index, v in enumerate(strings)])  # [(0, 'import'), (1, 'is'), (2, 'with'), (3, 'if'), (4, 'file'), (5, 'exception'), (6, 'liuhu')]
# 1.
print({val: index for index, val in enumerate(strings)})  # {'import': 0, 'is': 1, 'with': 2, 'if': 3, 'file': 4, 'exception': 5, 'liuhu': 6}
# 2.
print({strings[i]: i for i in range(len(strings))})  # {'import': 0, 'is': 1, 'with': 2, 'if': 3, 'file': 4, 'exception': 5, 'liuhu': 6}
# 3.
print({v: len(v) for v in strings})  # {'import': 6, 'is': 2, 'with': 4, 'if': 2, 'file': 4, 'exception': 9, 'liuhu': 5}

示例3：同一个字母但不同大小写的值合并起来，都合并到小写

# 同一个字母但不同大小写的值合并起来了
mc = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}

# 都合并到小写
print({k.lower(): mc.get(k.lower(), 0) + mc.get(k.upper(), 0) for k in mc.keys()})  # {'a': 17, 'b': 34, 'z': 3}

五、集合

无序不重复
只能包含不可变数据(数字、字符串、元组)

创建

# 创建
a = {}
print(type(a))  # <class 'dict'>
b = {3, 6, 7, 9}
print(type(b))  # <class 'set'>
print(b)  # {9, 3, 7, 6}

添加

# 添加
b.add('8')
print(b)  # {'8', 3, 6, 7, 9}

将其他数据类型转化为集合

# 将其他数据类型转化为集合
a = set(range(10))
print(a)
c = set([i for i in range(25)])
print(c)

删除

del c
print(c)  # name 'c' is not defined

update 方法

使用update()方法合并另外一个集合中的元素到当前集合中

# update 方法   使用update()方法合并另外一个集合中的元素到当前集合中
d = {1, 2, 4}
d.update({5, 7, 4})
print(d)  # {1, 2, 4, 5, 7}

pop()

# pop() 弹出并删除其中的一个元素
v = d.pop()
print(v)

remove

# remove 删除指定元素的值
d.remove(5)
print(d)

清空集合

# 清空集合
d.clear()
print(d)  # set()

并集、交集、差集

# 并集
# 1. a_set|b_set
# 2. a_set.union(b_set)
# 交集
# 1. a_set&b_set
# 2. a_set.intersection(b_set)
# 差集
# 1. a_set - b_set
# 2. a_set.difference(b_set)

使用集合快速提取序列中单一元素

# 使用集合快速提取序列中单一元素
from random import choice
# 随机选取序列中的一个元素
# print(choice(['a', 'b', 'c']))
# print(choice('asdfas'))
random_list = [choice(range(100)) for _ in range(200)]
print(random_list)
print(len(random_list))

生成一个norepeat的集合

# 生成一个norepeat的集合
noRepeat = []
for x in random_list:
    if x not in noRepeat:
        noRepeat.append(x)
print(len(noRepeat))
noRepeat = set(noRepeat)
print(noRepeat)

集合解析

# 集合解析
# 将列表转化为集合， 并且做每个元素两端去空格处理
s = ['   ddd', '  is  ', '  python   ']
print({x.strip() for x in s})  # {'python', 'is', 'ddd'}

Python正式课第四天

一、列表（补充）

切片

浅复制

二、元组 tuple

使用tuple函数将其他的序列转化为元组

1. 列表转化成元组

2. range函数

3. 字符串

元组和列表的区别

元组优点

三、字符串

字符串的切片

字符串常用操作方法

四、字典

使用dict函数将已有数据转化成字典

字典的读取

字典的修改

字典的添加

字典的删除

判断一个key 是否在字典中

字典的遍历

有序字典

字典推导式 （字典解析）

五、集合

创建

添加

将其他数据类型转化为集合

删除

update 方法

pop()

remove

清空集合

并集、交集、差集

使用集合快速提取序列中单一元素

生成一个norepeat的集合

集合解析

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

字典推导式（字典解析）