python学习笔记

最新推荐文章于 2024-02-22 20:46:26 发布

qq_45778406

最新推荐文章于 2024-02-22 20:46:26 发布

阅读量357

点赞数

分类专栏：笔记文章标签： python 学习开发语言

本文链接：https://blog.csdn.net/qq_45778406/article/details/129010067

版权

笔记专栏收录该内容

21 篇文章 0 订阅

订阅专栏

小的知识点

单个反斜杠，可以当作续行符
类中的函数调用同一个类中的函数必须加类名调用，而函数中定义的函数只需函数名即可调用
Counter() 是 collections 库中的一个函数，可以用来统计一个 python 列表、字符串、元组等可迭代对象中每个元素出现的次数，并返回一个字典
Python中enumerate用法详解
for l, c in enumerate(s, 0)： #此处l是从0开始， c是记录s中遍历的值
python中的逻辑运算符 or , and , not
True ,False 要大写首字母
字典的构造：hashtable = dict(), hashtable = {}
python也可以用小括号来控制逻辑运算优先级
列表增加元素， w.append(x)
10.python16进制转10进制， int(x, 16) , x可以是16进制的字符串

Python 直接赋值、浅拷贝和深度拷贝解析

直接赋值：其实就是对象的引用（别名）。

浅拷贝(copy)：拷贝父对象，不会拷贝对象的内部的子对象。

深拷贝(deepcopy)： copy 模块的 deepcopy 方法，完全拷贝了父对象及其子对象。
在这里插入图片描述

map函数

map是python内置函数，会根据提供的函数对指定的序列做映射。

map()函数的格式是：
map(function,iterable,...)
第一个参数接受一个函数名，后面的参数接受一个或多个可迭代的序列，返回的是一个迭代器。
def add(x):
    return x**2			#计算x的平方
lists = range(11)       #创建包含 0-10 的列表
a = map(add,lists)      #计算 0-10 的平方，并映射
print(a)                # 返回一个迭代器：<map object at 0x0000025574F68F70>
print(list(a))          # 使用 list() 转换为列表。结果为：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]




# 使用lambda匿名函数的形式复现上面的代码会更简洁一些
print(list(map(lambda x:x**2,range(11))))   # 结果为：[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]


把函数依次作用在list中的每一个元素上，得到一个新的list并返回。注意，map不改变原list，而是返回一个新list。


map实例
del square(x):
    return x ** 2

map(square,[1,2,3,4,5])

# 结果如下:
[1,4,9,16,25]
通过使用lambda匿名函数的方法使用map()函数：
map(lambda x, y: x+y,[1,3,5,7,9],[2,4,6,8,10])
# 结果如下：
[3,7,11,15,19]

通过lambda函数使返回值是一个元组：
map(lambda x, y : (x**y,x+y),[2,4,6],[3,2,1])

# 结果如下
[(8,5),(16,6),(6,7)]

当不传入function时，map()就等同于zip()，将多个列表相同位置的元素归并到一个元组：
map(None,[2,4,6],[3,2,1])

# 结果如下
[(2,3),(4,2),(6,1)]

通过map还可以实现类型转换

将元组转换为list：
`map(int,(1,2,3))

# 结果如下：
[1,2,3]

将字符串转换为list：
map(int,'1234')

# 结果如下：
[1,2,3,4]

提取字典中的key，并将结果放在一个list中：
map(int,{1:2,2:3,3:4})

# 结果如下
[1,2,3]

python算法竞赛输入输出

input() 函数的行为接近 C++ 中的 getline()，即将一整行作为字符串读入，且末尾没有换行符，返回值默认为string, 若需要其他类型需要切分和类型转换
适用于一行读多个以空格分割的数字——split()函数默认以空格分割


>>> s = input('请输入一串数字: '); s  # 自己调试时可以向 input() 传入字符串作为提示
请输入一串数字: 1 2 3 4 5 6
'1 2 3 4 5 6'
>>> a = s.split(); a
['1', '2', '3', '4', '5', '6']
>>> a = [int(x) for x in a]; a
[1, 2, 3, 4, 5, 6]
>>> # 以上输入过程可写成一行 a = [int(x) for x in input().split()]
>>> sum(a) / len(a)  # sum() 是内置函数
3.5

3.若一行数字不多，可以直接赋值，不使用列表

>>> u, v, w = [int(x) for x in input().split()]
1 2 4
>>> print(u,v,w)
1 2 4

若是遇见n行输入，读入二维数组形式

>>> N = 4; mat = [[int(x) for x in input().split()] for i in range(N)]
1 3 3 
1 4 1 
2 3 4 
3 4 1 
>>> mat  # 先按行读入二维数组
[[1, 3, 3], [1, 4, 1], [2, 3, 4], [3, 4, 1]]
>>> u, v, w = map(list, zip(*mat))   
# *将 mat 解包得到里层的多个列表
# zip() 将多个列表中对应元素聚合成元组，得到一个迭代器
# map(list, iterable) 将序列中的元素（这里为元组）转成列表
>>> print(u, v, w)  # 直接将 map() 得到的迭代器拆包，分别赋值给 u, v, w
[1, 1, 2, 3] [3, 4, 3, 4] [3, 1, 4, 1]
```上述程序实际上相当于先读入一个 N 行 3 列的矩阵，然后将其转置成 3 行 N 列的矩阵，也就是外层列表中嵌套了 3 个列表，最后将代表这起点、终点、权值的 3 个列表分别赋值给
 u, v, w。内置函数 zip() 可以将多个等长序列中的对应元素拼接在「元组」内，得到新序列。而 map() 其实是函数式编程的一种操作，它将一个给定函数作用于 zip() 所产生序列的元素，这里就是用 list() 将元组变成列表。你可以自行练习使用 * 和 zip()，map() 以理解其含义。需要注意的是 Python 3 中 zip() 和 map() 创建的不再返回列表而是返回迭代器，这里暂不解释它们之间的异同，你可以认为迭代器可以产生列表中的各个元素，用 list() 套住迭代器就能生成列表。

列表

列表的初始化

s1 = []
s1 = [int(i) for i in input().split()]
s1 = list(range(1, 20))

列表的删除

一、del函数

1、根据索引删除;

2、删除索引范围内的元素;

3、删除整个列表。

list1 = ['a','b','c','d','e','f','g'] 

del list1[1] print(list1) 

输出 ['a', 'c', 'd', 'e', 'f', 'g']

二、remove函数

1、根据元素检索删除;

2、删除第一个出现的对应元素;

3、确定列表种有某个元素，删除它。

实例

>>> a = [0, 2, 2, 3] 

>>> a.remove(2) 

>>> a [0, 2, 3]

三、pop 函数

1、pop()方法用于删除列表中的最后一个元素，并返回该元素本身；

2、pop(1)也可通过下标（从0开始）指定删除某个元素，并返回该元素本身；

3、pop(“name”)当传入字典的键，返回该键对应的值，并将该键值对从字典删除【必须传值】；

4、字典调用的pop(“name”，“age”)最多能传两个参数。

5、通过集合实例对象调用pop()不能传参，随机移除集合的一项并将其返回。

>>> a = [0, 2, 2, 3]

>>> a.pop()

>>> a [0, 2, 2]

>>> a = {1, 2 , "age"}

>>> a.pop()

>>> a {1, "age"}

列表切片

# 遍历列表中前三个元素，并打印出来
languages = ['Python', 'Java', 'C++', 'C#']
for language in languages[:3]:
    print(language)
 
# 输出结果
Python
Java
C++
languages = ['Python', 'Java', 'C++', 'C#']
languages_copy = languages[:]
print(languages)
print(languages_copy)
### 列表的复制
s1 = list(range(0, 5)
s2 = s1  #两者指向同一个列表
s3 = s1[:] #两者指向不同的列表


for x in s1[1:3:2]:
	print(x) #从1到3(取不到3), 步长为2


## 元组
一、元组的特点：
1、与列表相似，不同之处就在于元组的元素不能被修改。
2、列表使用的是中括号“[]”，元组使用的是小括号“()”。
3、列表属于可变类型，元组属于不可变类型。
4、Python内部对元组进行了大量的优化，访问喝处理速度都比列表快。
二、元组的创建、访问和删除
1、创建
创建有两种形式，与列表的创建类似
```py
#创建
tuple1 = tuple((1,2,3))         #创建了一个包括3个元素的元组对象
print(tuple1)
tuple2 = (1,2,3,4,5,6,7,8,9,10)
print(tuple2)

#打印结果
#(1, 2, 3)
#(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

当要创建的元组中只包含一个元素时，必须带逗号。如果不带逗号会将左右括号默认视为运算符。

tuple1= (100, )                     #创建一个元素的元组时，必须带有逗号
tuple2= (100)
print(tuple1[0])
#print(tuple2[0])					无法正确打印元组中第一个元素
#error： TypeError: 'int' object is not subscriptable

2、访问
元组的访问和列表的访问类似。可以访问打印整个元组中的元素，也可以打印下标所对应的元素。
⭐使用推导式生成并访问元组对象
注意：推导式复制后，元组中的元素并没有被同一生成，一直到访问到某个元素时，才会被及时生成

#使用推导式生成并访问元组对象
#创建
#注意：推导式复制后，元组中的元素并没有被同一生成，一直到访问到某个元素时，才会被及时生成
tuple1 = (value for value in range(1,11))            #返回一个迭代的对象
#访问
print(tuple1)
for i in tuple1:
    print(i)

#打印结果：
#<generator object <genexpr> at 0x033FCBF8>
#
#1
#2
#3
#4
#5
#6
#7
#8
#9
#10

3、删除
要是删除，不能只删除元组中的某个元素，如果要删除，那么就使用del删除整个元组。
4、更改元素错误
不能通过下标之间更改元组里面的值（因为规定元组中的元素不能被修改）
补充：当一个函数返回了多个值，那么Python内部会把多个值放在一个元组中返回。
5, 元组的加法

tuple_name1 = tuple(input().split())
tuple_name2 = tuple(input().split())
tuple_name3 = tuple_name1[:3] + tuple_name2[-3:]

列表排序

sort 与 sorted 区别

sort 是应用在 list 上的方法，属于列表的成员方法，sorted 可以对所有可迭代的对象进行排序操作。
list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。
sort使用方法为ls.sort()，而sorted使用方法为sorted(ls)

lambda表达式

1, lambda函数介绍

有时在使用函数时不需要给函数分配一个名称，该函数就是“匿名函数”。在python中使用lambda表达式表示匿名函数

语法：lambda 参数列表：lambda体

lambda是关键字声明，在lambda表达式中，参数列表与函数中的参数列表一样，但不需要用小括号括起来，冒号后面是lambda体，lambda表达式的主要代码在lambda体处编写，类似于函数体。

提示：lambda体不能是一个代码块，不能包含多条语句*，只能包含一条语句*，该语句会计算一个结果返回给lambda表达式，但与函数不同的是，不需要使用return语句返回，而且当使用函数作为参数的时候。lambda表达式非常有用，可以让代码简洁，简单。

2、lambda函数与def函数的区别

1.lambda可以立即传递（无需变量），自行返回结果

2.lambda在内部只能包含一行代码

3.lambda是一个为编写简单函数而设计的，而def用来处理更大的任务

4.lambda可以定义一个匿名函数，而def定义的函数必须有一个名字

lambda函数的优势：

1.对于单行函数，使用lambda表达式可以省去定义函数的过程，让代码更加简洁

2.对于不需要多次复用的函数，用lambda表达式可以在用完后立即释放，提高程序执行的性能。

3、lambda案例

# def函数写法
def add(a, b):
    return a + b
 
 
print(add(10, 20))
print("-" * 50)
 
 
# lambda函数写法
add_lambda = lambda a, b: a + b
print(add_lambda(10, 20))
 
 
# 使用if判断奇偶性
def get_odd_even(x):
    if x % 2 == 0:
        return "偶数"
    else:
        return "奇数"
 
 
print(get_odd_even(10))
 
 
# lambda函数写法
get_odd_even1 = lambda x: "偶数" if x % 2 == 0 else "奇数"
print(get_odd_even1(10))

将lambda作为函数返回
# 作为函数
def sum(a):
    return lambda b:a + b
a = sum(3)
print(a(4))
列表排序
a = [(2, "小黑"), (5, "小白"), (4, "张三"), (3, "王五")]
a.sort(key=lambda x: x[0])
print(a)

4、map方法混搭

遍历序列，对序列中每个元素进行操作，最终获得新的序列

from functools import reduce
 
 
def add(num):
    return num ** 2
 
 
x = map(add, [1, 2, 3, 4, 5])
print(x)
print(list(x))
print("_" * 50)
 
y = map(lambda num: num ** 2, [1, 2, 3, 4, 5])  # map()对序列中的每个元素进行操作，获得新的序列
print(list(y))
 
x = filter(lambda num: num % 2 == 0, [1, 2, 3, 4, 5])  # filter()对序列中的每个元素筛选，获得新的序列
print(list(x))
 
list1 = [1, 2, 3, 4, 5]
list2 = reduce(lambda x, y: x + y, list1)  # reduce()对序列中元素进行累加
print(list2)

filter函数的用法

描述

filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。

该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

语法

以下是 filter() 方法的语法:

filter(function, iterable)

参数

function – 判断函数。
filter会遍历iterable中的每一个数据，用function判断，符合条件，才会被留下。
iterable – 可迭代对象。
如列表，元组，甚至集合都可以。

返回值

返回一个迭代器对象

实例

#过滤出列表中的所有奇数：
def is_odd(n):
    return n % 2 == 1
 
tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)
print(newlist)
# 输出[1, 3, 5, 7, 9]

#过滤出1~100中平方根是整数的数： 
import math
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
 
tmplist = filter(is_sqr, range(1, 101))
newlist = list(tmplist)
print(newlist)
#输出结果 ：

#[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
filter：过滤

filter(function or None, iterable)
1. fuction or None：第一个参数可以是一个函数或者是None
iterable：可迭代对象
2. 如果给了function，则将可迭代对象中的每一个元素，传递给function作为参数，筛选出所有结
果为真的值。
3. 如果function没有给出，必须要给None，直接返回iterable中所有为真的值
真值：任何非零的值（包括负数）
假值：零，所有的空（空列表等） None, 0，False，所有的空

zip函数

zip() 接受一系列可迭代的对象作为参数，将对象中对应的元素打包成一个个 tuple，然后返回由这些 tuple 组成的 list。

若传入参数的长度不等，则返回 list 的长度和参数中长度最短的对象相同。

利用 * 号操作符，可以将 list 解压。

Python3.0开始，zip()函数已经不返回 list 了，而是返回 iterable(可迭代对象)。这个可迭代对象需要特别注意，只能进行一次迭代遍历，第二次遍历就是空了。

# 简单示例
a = [1, 2, 3]
b = [4, 5, 6]
c = [7, 8, 9, 10, 11]

ab = zip(a, b)
print(list(ab))     # [(1, 4), (2, 5), (3, 6)]
# zip()之后的结果只能“使用一次”
# zip()实际上是一个生成器对象，故使用list()获取zip()结果时，已经相当于是完成一次迭代遍历
# 第二次再次使用list()时迭代已经结束，所以返回[]
print(list(ab))     # []

ac = zip(a, c)
# print(list(ac))     # [(1, 4), (2, 5), (3, 6)]，以短的为准

_ac = zip(*ac)      # 与 zip 相反，可理解为解压，返回二维矩阵式
print(list(_ac))    # [(1, 2, 3), (7, 8, 9)]，如果没把上面的 print(list(ac)) 注掉，这里的显示结果就是[]了

# 应用示例一
print('应用示例一')
name = ('jack', 'alex', 'sony', 'joey')
age = (25, 28, 21, 30)
for a, n in zip(name, age):
    print(a, n)

# 应用示例二：二维矩阵行列转换
print('应用示例二')
a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(list(map(list, zip(*a))))  # [[1, 4, 7], [2, 5, 8], [3, 6, 9]], map()函数把zip(*a)后的每一个元素转化为list

按照给定步长遍历

lan = input().split()
for i in lan[::5]:
    print(i)

code = list(input().split())
for i in range(0, len(code), 5):
    print(code[i])

Python中range()函数的使用方法

1 基本语法

range()函数的基本语法如下所示。

range(start, stop)

其中，start表示这一些列数字中的第一个数字；stop-1表示这一系列数字中的最后一个数字。需要注意的是，产生的数字中不包括stop。

2 使用方法

range()函数产生的这一系列的数字并不是以列表（list）类型存在的，这样做的目的是为了节省代码所占空间。

将range()产生的数字转换为列表
list((range(0, 5))
[0, 1, 2, 3, 4]

在for语句中使用range()产生的数字
for i in range( 0, 5):
	print(i)
对range()产生的数字求和
sum(range(0, 5))

在“1 基本语法”中提到的range()函数语法产生的数字的步进默认是1，可以通过以下语法指定其步进
range(start, stop, step)

python中的字符串

三引号字符串可以扩展多行

my_str = """Hello, welcome to

           the world of Python"""

☆字符串是不可变数据类型，也就是说你要改变原字符串内的元素，只能是新建另一个字符串。换句话说，字符串是不可变的。这意味着字符串的元素一旦分配就无法更改。我们可以简单地将不同的字符串重新分配给相同的名称。
不能删除或删除字符串中的字符。但是使用del关键字可以完全删除字符串。

例如删除my_string = ‘Python’，可用如下语句：

del my_string

字符串的操作

在这里插入图片描述

f字符串（f-string）

以f开头的字符串，称之为f-string，是从python3.6引入的它和普通字符串不同之处在于，字符串如果包含{xxx}，就会以对应的变量替换：

r = 2.5
s = 3.14 * r ** 2

字符串的格式化常用函数：

lstrip 消除左边的指定字符

rstrip 消除右边的指定字符

strip 消除左右位置的指定字符

replace 替换成其他的

s=str(input())#假定输入是("###NIU NIU###")
print(s.strip('#')) # 会消除左右的‘#’
打印结果是“NIU NIU”

字符串的常用方法

capitalize()，将字符串的第一个字符转换为大写，不会修改原始字符串。
casefold()，把字符串大写字符转换为小写。不会修改原始字符串。
center(width, fillchar)返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
encode(encoding=‘UTF-8’,errors=‘strict’)以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’。
endswith(suffix, beg=0, end=len(string))检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False。
ljust(width[, fillchar])返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
lower()转换字符串中所有大写字符为小写。
lstrip([chars])截掉字符串左边的空格或指定字符。chars – 指定删除的字符（默认即缺省为空格）
maketrans()创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
max(str)返回字符串 str 中最大的字母。
min(str)返回字符串 str 中最小的字母。
replace(old, new [, max])把将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。
rfind(str, beg=0,end=len(string))类似于 find()函数，不过是从右边开始查找。
rindex( str, beg=0, end=len(string))类似于 index()，不过是从右边开始。
rjust(width,[, fillchar])返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串。
rstrip([chars])删除字符串末尾的空格或指定字符。chars – 指定删除的字符（默认即缺省为空格）
split(str=“”, num=string.count(str))以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串。
splitlines([keepends])按照行(‘\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
startswith(substr, beg=0,end=len(string))检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。
strip([chars])在字符串上执行 lstrip()和 rstrip()，chars – 指定删除的字符（默认即缺省为空格）
swapcase()将字符串中大写转换为小写，小写转换为大写。
title()返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())。
translate(table, deletechars=“”)根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中。
upper()转换字符串中的小写字母为大写。
zfill (width)返回长度为 width 的字符串，原字符串右对齐，前面填充0。
isdecimal()检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。
.lower() — 全部小写
.upper() — 全部大写
.title() — 各个字符的首字母大写
.capitalize() — 首字母大写

format()函数，可用于执行字符串格式化操作，

可以使用加号、字符串方法join、格式化、通过F-string拼接。源码如下：
a = "We"
b = "learn"
c = "Python"
s1 = a + " " + b + " " + c #通过+号拼接
print(s1)
 
seq = (a, b, c); # 字符串序列
s2 = " ".join(seq)#通过 str.join()方法拼接
print(s2)
 
s3 = "{0} {1} {2}".format(a,b,c)  #格式化拼接
print(s3)
 
s4 = f"{a} {b} {c}" #通过F-string拼接，适用于python3.6.2+版本
print(s4)

python中的字典

字典由键（key）和值（value）成对组成，键和值中间以冒号：隔开，项之间用逗号隔开，整个字典由大括号{}括起来。格式如下：

dic = {key1 : value1, key2 : value2 }

字典的创建方法

字典也被称作关联数组或哈希表。下面是几种常见的字典创建方式：

# 方法1
dic1 = { 'Author' : 'Python当打之年' , 'age' : 99 , 'sex' : '男' }

# 方法2
lst = [('Author', 'Python当打之年'), ('age', 99), ('sex', '男')]
dic2 = dict(lst)

# 方法3
dic3 = dict( Author = 'Python当打之年', age = 99, sex = '男') #自动将键变为str
# 方法4
list1 = ['Author', 'age', 'sex']
list2 = ['Python当打之年', 99, '男']
dic4 = dict(zip(list1, list2))

遍历字典的方法

一、常规遍历方式

在这里插入图片描述

二、向列表一样通过索引遍历字典的值

在这里插入图片描述

查看字典的所有方法

字典由 dict 类代表，可以使用 dir(dict) 来查看该类包含哪些方法，输入命令，可以看到如下输出结果：

methods = dir(dict)
print('methods = ',methods)

methods = ['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']

字典中常用方法

1、dict.clear()
clear() 用于清空字典中所有元素（键-值对），对一个字典执行 clear() 方法之后，该字典就会变成一个空字典。

list1 = ['Author', 'age', 'sex']
list2 = ['Python当打之年', 99, '男']
dic1 = dict(zip(list1, list2))
# dic1 = {'Author': 'Python当打之年', 'age': 99, 'sex': '男'}

dic1.clear()
# dic1 = {}

2、dict.copy()
copy() 用于返回一个字典的浅拷贝。

list1 = ['Author', 'age', 'sex']
list2 = ['Python当打之年', 99, '男']
dic1 = dict(zip(list1, list2))

dic2 = dic1 # 浅拷贝: 引用对象
dic3 = dic1.copy() # 浅拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，还是引用
dic1['age'] = 18

# dic1 = {'Author': 'Python当打之年', 'age': 18, 'sex': '男'}
# dic2 = {'Author': 'Python当打之年', 'age': 18, 'sex': '男'}
# dic3 = {'Author': 'Python当打之年', 'age': 99, 'sex': '男'}

拓展深拷贝：copy.deepcopy()
import copy

list1 = ['Author', 'age', 'sex']
list2 = ['Python当打之年', [18,99], '男']
dic1 = dict(zip(list1, list2))

dic2 = dic1
dic3 = dic1.copy()
dic4 = copy.deepcopy(dic1)
dic1['age'].remove(18)
dic1['age'] = 20

# dic1 = {'Author': 'Python当打之年', 'age': 20, 'sex': '男'}
# dic2 = {'Author': 'Python当打之年', 'age': 20, 'sex': '男'}
# dic3 = {'Author': 'Python当打之年', 'age': [99], 'sex': '男'}
# dic4 = {'Author': 'Python当打之年', 'age': [18, 99], 'sex': '男'}

3、dict.fromkeys()
fromkeys() 使用给定的多个键创建一个新字典，值默认都是 None，也可以传入一个参数作为默认的值。

list1 = ['Author', 'age', 'sex']
dic1 = dict.fromkeys(list1)
dic2 = dict.fromkeys(list1, 'Python当打之年')

# dic1 = {'Author': None, 'age': None, 'sex': None}
# dic2 = {'Author': 'Python当打之年', 'age': 'Python当打之年', 'sex': 'Python当打之年'}

4、dict.get()
get() 用于返回指定键的值，也就是根据键来获取值，在键不存在的情况下，返回 None，也可以指定返回值。

list1 = ['Author', 'age', 'sex']
list2 = ['Python当打之年', [18,99], '男']
dic1 = dict(zip(list1, list2))

Author = dic1.get('Author')
# Author = Python当打之年
phone = dic1.get('phone')
# phone = None
phone = dic1.get('phone','12345678')
# phone = 12345678

5、dict.items()
items() 获取字典中的所有键-值对，一般情况下可以将结果转化为列表再进行后续处理。

list1 = ['Author', 'age', 'sex']
list2 = ['Python当打之年', [18,99], '男']
dic1 = dict(zip(list1, list2))
items = dic1.items()
print('items = ', items)
print(type(items))
print('items = ', list(items))

# items = dict_items([('Author', 'Python当打之年'), ('age', [18, 99]), ('sex', '男')])
# <class 'dict_items'>
# items = [('Author', 'Python当打之年'), ('age', [18, 99]), ('sex', '男')]

6、dict.keys()
keys() 返回一个字典所有的键。

list1 = ['Author', 'age', 'sex']
list2 = ['Python当打之年', [18,99], '男']
dic1 = dict(zip(list1, list2))
keys = dic1.keys()
print('keys = ', keys)
print(type(keys))
print('keys = ', list(keys))

# keys = dict_keys(['Author', 'age', 'sex'])
# <class 'dict_keys'>
# keys = ['Author', 'age', 'sex']

7、dict.pop()
pop() 返回指定键对应的值，并在原字典中删除这个键-值对。

list1 = ['Author', 'age', 'sex']
list2 = ['Python当打之年', [18,99], '男']
dic1 = dict(zip(list1, list2))
sex = dic1.pop('sex')
print('sex = ', sex)
print('dic1 = ',dic1)

# sex = 男
# dic1 = {'Author': 'Python当打之年', 'age': [18, 99]}

8、dict.popitem()
popitem() 删除字典中的最后一对键和值。

list1 = ['Author', 'age', 'sex']
list2 = ['Python当打之年', [18,99], '男']
dic1 = dict(zip(list1, list2))
dic1.popitem()
print('dic1 = ',dic1)

# dic1 = {'Author': 'Python当打之年', 'age': [18, 99]}

9、dict.setdefault()
setdefault() 和 get() 类似, 但如果键不存在于字典中，将会添加键并将值设为default。

list1 = ['Author', 'age', 'sex']
list2 = ['Python当打之年', [18,99], '男']
dic1 = dict(zip(list1, list2))
dic1.setdefault('Author', '当打之年')
print('dic1 = ',dic1)
# dic1 = {'Author': 'Python当打之年', 'age': [18, 99], 'sex': '男'}
dic1.setdefault('name', '当打之年')
print('dic1 = ',dic1)
# dic1 = {'Author': 'Python当打之年', 'age': [18, 99], 'sex': '男', 'name': '当打之年'}

10、dict.update(dict1)
update() 字典更新，将字典dict1的键-值对更新到dict里，如果被更新的字典中己包含对应的键-值对，那么原键-值对会被覆盖，如果被更新的字典中不包含对应的键-值对，则添加该键-值对。

list1 = ['Author', 'age', 'sex']
list2 = ['Python当打之年', [18,99], '男']
dic1 = dict(zip(list1, list2))
print('dic1 = ',dic1)
# dic1 = {'Author': 'Python当打之年', 'age': [18, 99], 'sex': '男'}

list3 = ['Author', 'phone' ]
list4 = ['当打之年', 12345678]
dic2 = dict(zip(list3, list4))
print('dic2 = ',dic2)
# dic2 = {'Author': '当打之年', 'phone': 12345678}

dic1.update(dic2)
print('dic1 = ',dic1)
# dic1 = {'Author': '当打之年', 'age': [18, 99], 'sex': '男', 'phone': 12345678}

11、dict.values()
values() 返回一个字典所有的值。

list1 = ['Author', 'age', 'sex']
list2 = ['Python当打之年', [18,99], '男']
dic1 = dict(zip(list1, list2))
values = dic1.values()
print('values = ', values)
print(type(values))
print('values = ', list(values))

# values = dict_values(['Python当打之年', [18, 99], '男'])
# <class 'dict_values'>
# values = ['Python当打之年', [18, 99], '男']

python 中的print三种格式化输出

1 占位符

声明三个变量：姓名（string）、年龄（int）、身高（float）,见下方的一个简单实例。

>>> name = '小明'
>>> age = 20
>>> height = 1.85
>>> print("我是"+name+",年龄"+str(age))
我是小明,年龄20
>>> print("我是%s,年龄%d，体重%fm"%(name,age,height))
我是小明,年龄20，体重1.850000m

其中%s、%d便是占位符，顾名思义，其作用就是替后面的变量站住这个位置，
字符串后面的%是一个特殊的操作符，该操作符会将后面的变量值，替换掉前面字符串中的占位符.
常用占位符：

%c，格式化字符及其ASCII码
%s，格式化字符串
%d，格式化整数
%u，格式化无符号整数
%o，格式化无符号八进制数
宽度、对齐、精度

# 数值型
>>> pi = 3.1415926
>>> print('%10.3f' % pi) 
     3.142
# 宽度为10，右对齐，保留3位小数点
>>> print('%-10.10f' % pi) 
3.1415926000
# 宽度为10，左对齐，保留小数点后10位(不足10位补0)   

# 字符串
>>> print( "%.10s " % name) 
小明
# 输出10个字符，如果不足，输出全部
>>> print ("%.*s" % (6,name)) 
小明
# 左对齐，取6个字符
>>> print ("%10.6s" % name) 
        小明
 # 右对齐，宽度为10，取6个字符

2 format格式化

Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能，见下方简单示例。

>>> name = '小明'
>>> age = 20
>>> height = 1.85
>>> print("我是{},年龄{}，体重{}".format(name,age,height))
我是小明,年龄20，体重1.85

也可以通过指定位置编号操作，顺序从0开始，通过运行下方示例可以发现位置指定的作用。
>>> name = '小明'
>>> age = 20
>>> height = 1.85
>>> print("我是{0},年龄{1}，体重{2}".format(name,age,height))
我是小明,年龄20，体重1.85
>>> print("我是{1},年龄{2}，体重{0}".format(name,age,height))
我是20,年龄1.85，体重小明

宽度、对齐、精度

居中^
左对齐<
右对齐>
精度也是通过.来实现

>>> pi = 3.1415926
>>> print('{:>10.3f}'.format(pi))
     3.142
>>> # 宽度为10，右对齐，保留3位小数点
>>> print('{:<10.1f}'.format(pi))
3.1
>>> # 宽度为10，左对齐，保留1位小数点

3 fstring格式化

f-string格式化是python3.6引入了一种新的字符串格式化方式。

变量名直接做参数，比如name, age, height，注意不需要单引号或双引号,见下方示例。

>>> name = '小明'
>>> age = 20
>>> height = 1.85
>>> print(f'我是：{name}, 年龄：{age}, 身高：{height}m')
我是：小明, 年龄：20, 身高：1.85m

3.1 表达式参数

可以是直接的数值运算，也可以是变量赋值后运算。

>>> print(f'计算结果是：{2*5 + 3*4}')
计算结果是：22

>>> a = 90
>>> b = 9
>>> print(f'计算结果是：{a*b + a + b}')
计算结果是：909

3.2 宽度、对齐、精度

宽度为10，精度为小数点后2、3、4位，居中、居右、居左对齐，填充方式和format一样可以选择不同的字符。

>>> pi = 3.1415926
>>> print(f'{pi:^10.2f}')
   3.14
>>> print(f'{pi:>10.3f}')
     3.142
>>> print(f'{pi:<10.4f}')
3.1416

qq_45778406

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录