亲宝软件园·资讯

展开

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

可爱又迷人的 反派角色 人气:0
想了解python3.9之你应该知道的新特性详解的相关内容吗,可爱又迷人的 反派角色在本文为您仔细讲解python3.9新特性的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:python3.9新特性,python3.9新功能,下面大家一起来学习吧。

一、数字类型

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')

输出结果:

2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3

加载全部内容

相关教程
猜你喜欢
用户评论