python知识点

最新推荐文章于 2024-07-12 16:16:27 发布

无畏呀

最新推荐文章于 2024-07-12 16:16:27 发布

阅读量392

点赞数

文章标签： python 开发语言

本文链接：https://blog.csdn.net/m0_66105534/article/details/125481916

版权

python知识点备忘

文章目录

一、快捷键（python IDLE）
- - 1、返回（复制）上一条语句
二、知识点

一、快捷键（python IDLE）

1、返回（复制）上一条语句

AIt + p

二、知识点

1、数值交换

x , y = y , x

2、转义字符

用于:’’’life is short,let\’ use python”’

3、原始字符串（使转义字符失效）

Print（r”a\tdsfg\ndfgb\tsadsf”）

结果: a\tdsfg\ndfgb\tsadsf

4、三个单引号或双引号的使用：括号中内容会原样保存（包括换行）

5、浮点数的精准运算模块----decimal

使用原因：

0.1+0.2
0.30000000000000004

0.1 + 0.2 == 0.3
False

运用decimal后

import decimal
a = decimal.Decimal('0.1')
b = decimal.Decimal('0.2')
print(a + b)
0.3
c = decimal.Decimal('0.3')
a + b == c
True

6、科学计数法

0.00000006
6e-08		#0.6*10负8次方

7、复数

x = 1 + 2j
x.real
1.0
x.imag
2.0

8、地板除— //

3 // 2
1
-3 // 2
-2				#结果向下取整

9、内置函数

（1）divmod

divmod(x , y)返回（x // y , x % y）

divmod(5 , 2)
(2, 1)

（2）abs

取绝对值（模）

abs(-6)
6

abs(1 + 2j)
2.23606797749979
pow(5 , 0.5)
2.23606797749979

pow函数基础功能不再赘述

（3）pow

pow(2 , 3 , 6)
2				
#等价于
2 ** 3 % 6
2

（4）bool（）

用于返回一个布尔类型的值（True 或者 False）

>>> bool(250)
True
>>> bool("False")
True
>>> bool(0.0)
False
>>> bool([])
False
>>> bool(range(0))
False

（5）len（）

返回值：

返回对象的长度（包含元素的数量）。
基本用法：

>> len("FishC")
5

（6）range（）

通常用于配合 for 循环指定循环的次数。

range() 有三种参数的组合使用方式，但无论选择哪一种，其参数类型仅能为整数。

如果 step 参数忽略，那么默认的步进跨度值为 1。

三种形式：

range(stop)

range(start , stop)

range(start , stop , step)

示例:

for i in range(10):
    print(i , end=' ')
print()
print("······")
for i in range(4 , 10):
    print(i , end = ' ')
print()
print("······")
for i in range(5 , 20 , 2):
    print(i , end = ' ')
print()
print("······")

结果：

0 1 2 3 4 5 6 7 8 9 
······
4 5 6 7 8 9 
······
5 7 9 11 13 15 17 19 
······

说明：

range（）中stop为不包含

10、类型转换

complex("1+2j")
(1+2j)
complex("1 + 2j")
Traceback (most recent call last):
  File "<pyshell#37>", line 1, in <module>
    complex("1 + 2j")
ValueError: complex() arg is a malformed string

转换时不能有空格

11、x ** y

x的y次方

2 ** 3
8

12、短路逻辑

3 and 0
0
0 and 1
0
0 or 3
3
3 or 0		#3 or 0 在读取到‘3 or’时已经可以得出结果
3			#无需再继续读取，py直接扔出‘3’

13、优先级

and大于or

python优先级

14、分支结构

elif等于C语言中else if

(1)条件表达式

不喜欢用。。。。。

a = 6
b = 8
small = a if a < b else b
print(small)
'''
不能像下面这样，会报错
a = 6
b = 8
small = a if a < b else small = b
print(small)
'''

（2）分支嵌套

a = 3
b = 1
c = 2
if a < b:
    if a < c:
        small = a
        print(small)
else:
    if b < c:
        small = b
        print(small)
    else:
        small = c
        print(small)

**注：**if判断后需要有：

else后同样需要：

不能print（small = a）

15、循环结构

（1）while

a = 0
sum = 0
while a < 10 :
    sum = sum + a
    a = a + 1

    
print(sum)
45

**注1：**判断条件后要有:

**注2：**python中不能变量++

b = 0
b ++
SyntaxError: invalid syntax
b++
SyntaxError: invalid syntax
b++;
SyntaxError: invalid syntax

[1]while…else…

当循环正常退出时，才执行else里内容

#源代码
day = 1
while day < 8:
    anwser = input("今天进步一点点了吗？")
    if anwser == "是的！":
        print("真棒！")
    else:
        break
    day = day + 1
else:
    print("好厉害^o^")

#循环异常退出（break使循环结束）时情况
======================= RESTART: G:\python\_work\work1.py ======================
今天进步一点点了吗？不是

#循环正常结束时情况
======================= RESTART: G:\python\_work\work1.py ======================
今天进步一点点了吗？是的！
真棒！
今天进步一点点了吗？是的！
真棒！
今天进步一点点了吗？是的！
真棒！
今天进步一点点了吗？是的！
真棒！
今天进步一点点了吗？是的！
真棒！
今天进步一点点了吗？是的！
真棒！
今天进步一点点了吗？是的！
真棒！
好厉害^o^

[2]whlie循环嵌套

#九九乘法表
i = 1
while i <= 9:
    j = 1
    while j <= i:
        print(j,"*",i,"=",j*i,end=" ")
        j += 1
    print()
    i += 1

执行结果：

======================= RESTART: G:\python\_work\work1.py ======================
1 * 1 = 1 
1 * 2 = 2 2 * 2 = 4 
1 * 3 = 3 2 * 3 = 6 3 * 3 = 9 
1 * 4 = 4 2 * 4 = 8 3 * 4 = 12 4 * 4 = 16 
1 * 5 = 5 2 * 5 = 10 3 * 5 = 15 4 * 5 = 20 5 * 5 = 25 
1 * 6 = 6 2 * 6 = 12 3 * 6 = 18 4 * 6 = 24 5 * 6 = 30 6 * 6 = 36 
1 * 7 = 7 2 * 7 = 14 3 * 7 = 21 4 * 7 = 28 5 * 7 = 35 6 * 7 = 42 7 * 7 = 49 
1 * 8 = 8 2 * 8 = 16 3 * 8 = 24 4 * 8 = 32 5 * 8 = 40 6 * 8 = 48 7 * 8 = 56 8 * 8 = 64 
1 * 9 = 9 2 * 9 = 18 3 * 9 = 27 4 * 9 = 36 5 * 9 = 45 6 * 9 = 54 7 * 9 = 63 8 * 9 = 72 9 * 9 = 81

(2)for

for 变量 in 可迭代对象

statement(s)

示例1：

>>>for each in "xiao kun kun":
    print(each)

    
x
i
a
o
 
k
u
n
 
k
u
n

示例2：

for i in range(10):
    print(i , end=' ')
print()
print("······")
for i in range(4 , 10):
    print(i , end = ' ')
print()
print("······")
for i in range(5 , 20 , 2):
    print(i , end = ' ')
print()
print("······")

结果2：

0 1 2 3 4 5 6 7 8 9 
······
4 5 6 7 8 9 
······
5 7 9 11 13 15 17 19 
······

[1]for循环嵌套

#找出十以内所有素数
k = 0
for i in range(1, 11):
    k = 0
    for j in range(2, i):
        if i % j != 0:
            k += 1
    if k == i - 2:
        print(i,"是素数")

2 是素数
3 是素数
5 是素数
7 是素数

使用while（for）…else…结构的进阶版：

哈哈哈，这么简单的小程序还有进阶版，没想到吧^O

#找出十以内所有素数进阶版
for i in range(1, 11):

    for j in range(2, i):
        if i % j == 0:
            break
    else:
        print(i,"是素数")

1 是素数
2 是素数
3 是素数
5 是素数
7 是素数

确实不需要增加变量（k）来计数了，真不错

16、列表

（1）可存放不同类型数据

time = ["现在是晚上", 23, "点", 29, "分"]
print(time)
['现在是晚上', 23, '点', 29, '分']

(2)配合for循环使用

for time in time:
    print(time, end=' ')

现在是晚上 23 点 29 分

（3）列表索引

#列表下标也可为负数
time = ["现在是晚上", 23, "点", 29, "分"]
i = len(time)
while i > 0:
    print(time[-i],end=' ')
    i -= 1

现在是晚上 23 点 29 分

(4)列表切片

time = ["现在是晚上", 23, "点", 29, "分"]
print(time[0:3])
['现在是晚上', 23, '点']

[1]列表切片不对列表下标越界处理，如下

time[4:6]
['分']
time[4:100]
['分']
time[5:100]
[]
time[20:100]
[]

[2]列表切片中数字问题

列表切片中十进制整数字面值中不允许前导零;八进制整数使用0o前缀

time = ["现在是晚上", 22, "点", 06, "分"]
SyntaxError: leading zeros in decimal integer literals are not permitted; use an 0o prefix for octal integers

[3]可设置跨度

#name[start:end:跨度]
number = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
number[2:9:2]
[3, 5, 7, 9]

[4]倒叙输出

time = ["现在是晚上", 22, "点", 6, "分"]
print(time[::-1])
['分', 6, '点', 22, '现在是晚上']

[5]增/删/改/查

{1.1}增:append（）

在列表尾部加入新元素（一次只能加一个元素）

#错误示范
time.append(36, "秒")
TypeError: list.append() takes exactly one argument (2 given)

#正确示范
time.append(36)
time.append("秒")
time
['现在是晚上', 22, '点', 6, '分', 36, '秒']

{1.2}extend([])

对象为可迭代对象，追加在列表后面

time = ["现在是晚上", 22, "点", 6, "分"]
time
['现在是晚上', 22, '点', 6, '分']
time.extend([36,"秒"])
time
['现在是晚上', 22, '点', 6, '分', 36, '秒']

{1.3}使用列表切片增加

#增加一个元素
time = ["现在是晚上", 22, "点", 6, "分"]
time[len(time):] = [36]
time
['现在是晚上', 22, '点', 6, '分', 36]
time = ["现在是晚上", 22, "点", 6, "分"]
#增加多个元素
time[len(time):] = [36, "秒"]
time
['现在是晚上', 22, '点', 6, '分', 36, '秒']

{1.4}插入到中间（或任意位置）

time = ["现在是晚上", 22]
time.insert(2,"点")
time
['现在是晚上', 22, '点']

{2.1}删remove（）

#存在多个被删元素时，只删除第一个
abc = [1, 2, 3, 4, 1, 2, 3]
abc.remove(1)
abc
[2, 3, 4, 1, 2, 3]

**注：**被删元素不存在时，程序报错

abc = [1, 2, 3, 4, 1, 2, 3]
abc.remove(10)
ValueError: list.remove(x): x not in list

{2.2}使用下标删除pop（）

qwe = [123, 456, 789]
qwe.pop(0)
123
qwe
[456, 789]

{2.3}清空clear（）

qwe = [123, 456, 789]
qwe.clear()
qwe
[]

{3.1}改

#简单下标索引更改
qwe = [123, 456, 789]
qwe[0] = 369
qwe
[369, 456, 789]
#一次更改多个元素
qwe = [123, 456, 789]
qwe[2:] = [159, 487, 753]	#从第二个后面开始更改
qwe
[123, 456, 159, 487, 753]

{3.2}排序

#从小到大
number = [1, 9, 2, 7, 0, 6, 3]
number.sort()
number
[0, 1, 2, 3, 6, 7, 9]
#第一与最后一个元素互换，第二与倒数第二......
number = [1, 9, 2, 7, 0, 6, 3]
number.reverse()
number
[3, 6, 0, 7, 2, 9, 1]
#从大到小
number = [1, 9, 2, 7, 0, 6, 3]
number.sort()
number.reverse()
number
[9, 7, 6, 3, 2, 1, 0]
#从大到小（2）
number = [1, 9, 2, 7, 0, 6, 3]
number.sort(reverse=True)	#T要大写
number
[9, 7, 6, 3, 2, 1, 0]

{4.1}查count（）

#查元素个数
num = [1,5,4,84,1,1,1,1]
num.count(1)
5
#查元素下标
wsx = ["abc","qwe","rgy","qwe"]
wsx.index("qwe")
1	#有相同元素时返回第一个被查元素的下标
#index（被查，start，end）
wsx = ["abc","qwe","rgy","qwe"]
wsx.index("qwe",2,4)
3
#不包括end这个元素
wsx = ["abc","qwe","rgy","qwe"]
wsx.index("qwe",2,3)
ValueError: 'qwe' is not in list

{5.1}改copy()

numbers_copy = number.copy()
numbers_copy
[9, 7, 6, 3, 2, 1, 0]

{6}加、乘

#加
i = [1, 2, 3]
j = [4, 5, 6]
i + j
[1, 2, 3, 4, 5, 6]
#乘
i*3
[1, 2, 3, 1, 2, 3, 1, 2, 3]

{7}嵌套（多维列表）

创立:

a = [[1, 2, 3],
     [4, 5, 6],
     [7, 8, 9]]
a
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

访问：

需使用循环

for i in a:
    for j in i:
        print(j,end=" ")
    print()

1 2 3 
4 5 6 
7 8 9

下标访问:

a[0][0]
1

{8}初始化的两种看似相同实则不同的方法

for i in range(3):
    a[i] = [0]*3

a
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
b = [[0]*3]*3
b
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]

两种结果看似相同，第二种甚至不需要使用循环就创建了一个二维列表

但，实际上两种方法在内存上有很大差别

先展示区别

a[1][1] = 1
a
[[0, 0, 0], [0, 1, 0], [0, 0, 0]]
b[1][1] = 1
b
[[0, 1, 0], [0, 1, 0], [0, 1, 0]]

a列表在更改a【1】【1】时实实在在就是更改a【1】【1】

而b列表在更改b【1】【1】时，却更改了所有的第二列元素

在此介绍一个运算符-------is

is运算符用于检验两个变量是否指向同一个变量

举例:

x = 'xiaokunkun'
y = 'xiaokunkun'
x is y
True
a = 1
b = 2
a is b
False

{9}深拷贝

import copy
x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
y = copy.deepcopy(x)
x[1][1] = 0
x
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
y
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

{10}列表推导式

#示例一
oho = [1, 2, 3, 4, 5, 6]
owo = [i*2 for i in oho]
owo
[2, 4, 6, 8, 10, 12]
#示例二
matrix = [[1, 2, 3],
          [4, 5, 6],
          [7, 8, 9]]
diag = [matrix[i][i] for i in range(len(matrix))]
diag
[1, 5, 9]