python3.9之你应该知道的新特性详解_Python

一、数字类型

python除了支持原有的int和float类型，新增了支持Decimal或者Fraction。python还内置支持复数，后缀j或者J用于标识虚数。

二、字符串

如果字符串中有单引号而没有双引号，该字符串外将加注双引号，反之，则加注单引号。print() 函数输出的内容更简洁易读，它会省略两边的引号，并输出转义后的特殊字符。

				?

									>> '"Isn\'t," they said.'

									'"Isn\'t," they said.'

									>>> print('"Isn\'t," they said.')

									"Isn't," they said.

									>>> s = 'First line.\nSecond line.'  # \n means newline

									>>> s  # without print(), \n is included in the output

									'First line.\nSecond line.'

									>>> print(s)  # with print(), \n produces a new line

									First line.

									Second line.

如果不希望前置的\字符转译成特殊字符，可以使用原始字符串，在引号前添加r即可。

				?

									>>> print('C:\some\name')  # h这里的\n会被认为是转义字符

									C:\some

									ame

									>>> print(r'C:\some\name')  #在转义之前标记为r

									C:\some\name

字符串可以使用+合并到一起，也可以使用*表示复制多次

				?

									>>>3 * 'mmm'  + ‘qqq'

									>'mmmmmmmmmqqq'

相邻的两个或者多个字符串会自动合并

				?

									>>>'Py' 'thon'

									>‘Python'

拆分长字符串时，这个功能特别实用：

				?

									>>>('Put several strings within parentheses '

									...         'to have them joined together.')

									>>>text

									>'Put several strings within parentheses to have them joined together.'

这个功能只能用于两个字面值，不能用于变量或者表达式：

				?

									>>> prefix = 'Py'

									>>> prefix 'thon'  # can't concatenate a variable and a string literal

									  File "<stdin>", line 1

									    prefix 'thon'

									                ^

									SyntaxError: invalid syntax

									>>> ('un' * 3) 'ium'

									  File "<stdin>", line 1

									    ('un' * 3) 'ium'

									                   ^

									SyntaxError: invalid syntax

合并多个变量或者合并变量与字面值，要使用“+”：

				?

									>>> prefix + 'thon'

									'Python'

字符串支持索引，正向索引和反向索引都支持。

				?

									str[0]  str[1]  str[-1]

									#为什么反向索引从-1开始?

									#-0 和 0 相等，指向的是同一个值。

python支持切片操作。索引可以提取单个字符，切片操作可以提取字符串。

				?

									>>> word[0] 

									'P'

									>>> word[2:5] 

									'tho'

python切片操作输出结果包含切片开始，但是不包含切片结束。因此s[:i] + s[i:]总是等于s

				?

									>>> word[:2] + word[2:]

									'Python'

									>>> word[:4] + word[4:]

									'Python'

python可以自动处理越界索引：

				?

									>>> word[4:42]

									'on'

									>>> word[42:]

									''

python字符串是不可变量，所以直接对某个索引复制会报错。如果想改变字符串的值，必须新建一个字符串。

三、列表类型

python列表是个很神奇的类型，列表中添加的元素可以是不同的数据类型。与python字符串一样，python列表也支持索引和切片操作。

切片操作会返回包含请求元素的新列表。返回的是列表的浅拷贝。

				?

									#补充：深拷贝和浅拷贝的区别：

									#使用浅拷贝，当原容器对象中可变对象中有元素发生变化，拷贝得到的对象也会变#化。而使用深拷贝时，不会有这种问题。

									#!/usr/bin/python

									# -*- coding:utf-8 -*-

									# @Author : qmt

									# @Time : 2021/4/27 21:26

									import copy

									# 浅拷贝

									list1 = [[1,1], 555 , 'mm']

									list2 = list1.copy()

									list3 = copy.copy(list1)

									print(id(list1))

									print(id(list2))

									print(id(list3))

									# 输出结果

									# 2207574630976

									# 2207574779456

									# 2207574778816

									print(id(list1[0]))

									print(id(list2[0]))

									# 输出结果：

									# 2287435172736

									# 2287435172736

									print(id(list1[1]))

									print(id(list2[1]))

									# 输出结果：

									# 2085715335536

									# 2085715335536

									print(id(list1[2]))

									print(id(list2[2]))

									print(id(list3[2]))

									# 输出结果：

									# 3009054756720

									# 3009054756720

									# 3009054756720

									# 改变第一个值，查看复制对象的变化

									list1[0][0] = 100

									print(list1)

									print(list2)

									print(list3)

									# 输出结果：

									# [[100, 1], 555, 'mm']

									# [[100, 1], 555, 'mm']

									# [[100, 1], 555, 'mm']

									list1[2] = 32

									print(list1)

									print(list2)

									print(list3)

									# 输出结果：

									# [[100, 1], 555, 32]

									# [[100, 1], 555, 'mm']

									# [[100, 1], 555, 'mm']

									# 字符串是不可变对象，所以浅拷贝不会同步到其他复制对象中

									list1[1] = 'mm'

									print(list1)

									print(list2)

									print(list3)

									# 输出结果：

									# [[100, 1], 'mm', 32]

									# [[100, 1], 555, 'mm']

									# [[100, 1], 555, 'mm']

深拷贝：

				?

									#!/usr/bin/python

									# -*- coding:utf-8 -*-

									# @Author : qmt

									# @Time : 2021/4/27 21:35

									import copy

									list1 = [[1,2],'mm',2222]

									list2 = copy.deepcopy(list1)

									print(id(list1))

									print(id(list2))

									# 输出结果：指向不同的内存地址

									# 2847485493888

									# 2847485646528

									list1[0][0] = 100

									print(id(list1))

									print(id(list2))

									# 输出结果：list2作为一个深拷贝对象，内存地址并没有发生变化

									# 1368800613056

									# 1368800441920

									list1[2] = 100

									print(list1)

									print(list2)

									# 输出结果：list1的任何操作都不会对list2产生影响，因为这相当于创建了一个新的对象

									[[100, 2], 'mm', 100]

									[[1, 2], 'mm', 2222]

总结：

可变类型 Vs 不可变类型
可变类型（mutable）：列表，字典
不可变类型（unmutable）：数字，字符串，元组

深拷贝会把可变对象也拷贝一份，而浅拷贝不会。

上面例子中说的是列表（可变对象）的拷贝，那对于元组，字符等不可不对象呢？

答案是，对不可变对象，其实不存在深浅拷贝的问题。无论怎么拷贝，效果都是新建立一个指向不可变对象的指针而已。

				?

									import copy

									a = (1,2)

									b = copy.copy(a)

									c =copy.deepcopy(a)

									print(b == c)

									print(id(b)==id(c))

									lista = [5,6]

									listb = copy.copy(lista)

									listc = copy.copy(lista)

									print(listb == listc)

									print(id(lista) == id(listb))

输出结果：

True
True
True
False

				?

									Python中的对象包含三个基本要素，分别是：

									id：用来唯一标识一个对象，可以理解为内存地址；

									type：标识对象的类型；

									value：对象的值；

									== ：比较两个对象的内容是否相等，即两个对象的 value 是否相等，无论 id 是否相等，默认会调用对象的 __eq__()方法

									is： 比较的是两个对象是不是完全相同，即他们的 id 要相等。

									也就是说如果  a is b  为 True，那么 a == b 也为True

四、for循环

				?

									for n in range(2,10):

									    for x in range(2,n):

									        if n % x == 0:

									            print(n ,'equals',x ,'*', n//x)

									            break

									    else:

									        print(n,'is a prime number')