python-notes

python笔记

pycharm常用快捷键

ctrl+alt+s 打开软件设置
ctrl+d 复制当前行代码
shift+alt+上/下 将当前行代码上移或下移
ctrl+shift+f10 运行当前代码文件
shift+f6 重命名文件
ctrl+a 全选
ctrl+f 搜索
ctrl+alt+L reformat code
ctrl+alt+shift+L reformat file
ctrl+/ 注释选中行

1print语句

print()默认结尾换行,如果不需要换行可以添加end=‘’

1
2
print("hello", end='')
print("world")
1
helloworld
1
2
print("hello\tworld")
print("hello\nworld")
1
2
3
hello	world
hello
world

2.1字面量python六种数据类型

image-20230703204741768

1
2
3
print(999)
print(114.514)
print("hello world")

2.2注释

1
2
3
4
5
6
7
"""
这个是多行注释
"""
# 这个是单行注释（#号和注释内容一般建议一个空格隔开）
'''
这个也是多行注释
'''

2.3变量

1
2
3
money = 10
money = money - 5
print("余额为", money, "元")
1
余额为 5 元

2.4数据类型

1
2
3
4
string_type = type("hello world")
int_type = type(666)
float_type = type(114.514)
print(string_type, int_type, float_type)
1
<class 'str'> <class 'int'> <class 'float'>

2.5数据类型转换

语句(函数) 说明
int(x) 将x转换为一个整数
float(x) 将x转换为一个浮点数
str(x) 将对象x转换为字符串

万物皆可转字符串,只有字符串是数字时才能将字符串转数字

1
2
3
4
5
6
7
8
9
10
float_str = str(114.514)
print(type(float_str), float_str)
num = int("11")
print(type(num), num)
num2 = float("1919.810")
print(type(num2), num2)
fnum = float(11)
print(type(fnum), fnum)
inum = int(114.514)  # 不会四舍五入，直接取整
print(type(inum), inum)
1
2
3
4
5
<class 'str'> 114.514
<class 'int'> 11
<class 'float'> 1919.81
<class 'float'> 11.0
<class 'int'> 114

2.6标识符

标识符命名只允许出现:

  • 英文字母
  • 中文(不推荐)
  • 数字(不可以开头)
  • 下划线_

2.7运算符

image-20230703215458152

image-20230704075044254

image-20230703215659037

image-20230703215750236

1
2
3
4
print(1/3)
print(-17/4)
print(-17//4)
print(10//4)
1
2
3
4
0.3333333333333333
-4.25
-5
2

整除取整方向默认为−∞-\infin

Python 中一般以新行作为语句的结束标识，可以使用 \ 将一行语句分为多行显示。如下所示：

1
2
3
4
5
6
a = 128
b = 1024
c = 512
d = a + \
    b - \
    c

如果包含在 []、{}、() 括号中，则不需要使用 \。如下所示：

1
2
3
4
5
arr = {
    a,
    b,
    c
}

2.8字符串的三种定义方式

1
2
3
4
5
6
7
8
9
10
# 单引号定义法
name1='hello'
# 双引号定义法
name2="hello"
#三引号定义法
name3="""
hello
world
"""
print(name3)
1
2
3

hello
world

单引号定义法,可以内含双引号

双引号定义法,可以内含单引号

可以用转义字符\解除引号的效用

2.9字符串拼接

1
2
3
4
s1 = "abcd"
s2 = "defg"
s3 = s1 + s2
print(s3)
1
abcddefg

2.10字符串格式化

1
2
3
4
5
6
num = 114514
s = "abcde"
message1 = "%s你好世界" % s
print(message1)
message1 = "%s你好世界%s" % (s, num)
print(message1)
1
2
abcde你好世界
abcde你好世界114514
1
2
3
4
5
s = "绩点"
gpa = 0.1
num = 666
message = "%s高达%f,老铁%d" % (s, gpa, num)
print(message)
1
绩点高达0.100000,老铁666

字符转ASCII和ASCII转字符串

1
2
print(ord("a"))
print(chr(97))
1
2
97
a

字符串的大小写转化

1
2
3
4
5
6
7
8
9
# title将首字母变成大写,其余小写
str = "wHat a beaUTIFul GIrl!!"
print(str.title())
# upper将所有字母变成大写
str = "Cpp Is The Best Programing Language"
print(str.upper())
# lower将所有字母变成小写
str = "I HATE PYTHOn"
print(str.lower())
1
2
3
What A Beautiful Girl!!
CPP IS THE BEST PROGRAMING LANGUAGE
i hate python

2.11数字精度控制

image-20230703224027306

image-20230703224237500

2.12字符串格式化的一种快速写法

格式:f”内容{变量}”(不关心精度控制)

1
2
3
4
5
s = "绩点"
gpa = 0.1
num = 666
message = f"{s}高达{gpa},大佬{num}"
print(message)
1
绩点高达0.1,大佬666

2.15input语句

1
2
name = input("你是谁？")
print("ohhhhhhh!您就是那位著名的%s" % name)
1
2
你是谁？练习时长两年半的个人练习生
ohhhhhhh!您就是那位著名的练习时长两年半的个人练习生

input默认接受类型为string字符串

3条件语句

bool类型表示逻辑,True记作1,False记作0

python中的与或非: and or not

参考链接

1
2
3
num1 = 11
num2 = 20
print(f"11>20结果是{11 > 20},类型为{type(11 > 20)}")
1
11>20结果是False,类型为<class 'bool'>
1
2
3
4
5
6
7
num = int(input())
if num < 10:
    print(f"{num}<10")
elif num <= 100:
    print(f"{num}<=100")
else:
    print(num)
1
2
20
20<=100
1
2
3
4
5
6
num = int(input())
if num <= 100:
    pass  # pass 是空语句，它不做任何事情，一般用做占位语句，作用是保持程序结构的完整性。
else:
    print(num)

4.1循环语句while

1
2
3
4
5
6
x = 1
add = 0
while x <= 100:
    add += x
    x += 1
print(add)
1
5050

4.2循环语句for

for 临时变量 in 序列类型:

字符串和range语句生成的都是序列类型

1
2
3
4
5
6
7
s = "abcdef"
for ch in s:
    if ch == "a":
        continue
    if (ch == "e"):
        break
    print(ch)
1
2
3
b
c
d

range(num)

获得一个从0开始,到num结束的数字序列

range(5)取得的数据是[0,1,2,3,4]

range(num1,num2)

获得从num1开始,到num2结束的数字序列(不含num2本身)

range(5,10)取得的数据是[5,6,7,8,9]

range(num1,num2,step)

获得从num1开始,到num2结束的数字序列(不含num2本身)

数字间的步长,以step为准(默认为1)

例如,range(5,10,2)取得的数据为[5,7,9]

1
2
for x in range(5, 11, 2):
    print(x, end=' ')
1
5 7 9
1
2
3
for i in range(10, 0, -1):
    print(i, end=' ')
print()
1
10 9 8 7 6 5 4 3 2 1

reduce代替for循环

reduce函数在python2中是个内置函数，在python3中被移到functools模块中。

1
2
3
4
5
6
from functools import reduce
def add(x,y):
    return x+y
ar=[1,2,3,4,5]
accumulate=reduce(add,ar)
print(accumulate)
1
15

解释: 1+2+3+4+5=15

作用:它用于对一个可迭代对象进行累积操作，将一个二元函数应用于序列的前两个元素，然后将结果与下一个元素继续应用该函数，直到序列中的所有元素都被处理完毕。

5函数

1
2
3
4
5
6
7
8
9
def strlen(s):
    a = 0
    for i in s:
        a += 1
    return a


s1 = "hello world"
print(strlen(s1))
1
11

对于没有返回值的函数,返回值为None类型(也可以return None或return)

1
2
3
4
5
def nofunc():
    print("nofunc")


print(nofunc(), type(nofunc()))
1
2
3
nofunc
nofunc
None <class 'NoneType'>

在if判断中None等同于False

None也可用于声明无初始内容的变量

1
2
3
4
a = None
print(a, type(a))
a = 1
print(a, type(a))
1
2
None <class 'NoneType'>
1 <class 'int'>

函数说明文档:

1
2
3
4
5
6
7
8
9
10
11
12
def add(x, y):
    """
    add函数可以接受2个参数，进行两数相加
    :param x:第一个数字
    :param y:第二个数字
    :return:两数之和
    """
    result = x + y
    return result


print("1+2=", add(1, 2))

注:函数内定义的变量在函数外是完全不可访问的

函数外定义的全局变量函数内可以访问

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
num = 200


def test_a():
    print(f"test_a{num}")


def test_b():
    num = 500  # 局部变量
    print(f"test_b{num}")


test_a()
test_b()
print(num)
1
2
3
test_a200
test_b500
200
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
num = 200


def test_a():
    print(f"test_a{num}")


def test_b():
    global num
    num = 500  # 全局变量
    print(f"test_b{num}")


test_a()
test_b()
print(num)
1
2
3
test_a200
test_b500
500

6.1 list数据容器-列表

定义列表

1
2
3
4
5
6
7
8
9
10
11
name_list = ["abc", "def", "ghi"]
print(name_list)
print(type(name_list))
# 列表可以存储多种不同元素
my_list = ["abc", 666, True]
print(my_list)
print(type(my_list))
# 列表支持嵌套
two_dimension = [[1, 2, 3], [4, 5, 6]]
print(two_dimension)
print((type(two_dimension)))
1
2
3
4
5
6
['abc', 'def', 'ghi']
<class 'list'>
['abc', 666, True]
<class 'list'>
[[1, 2, 3], [4, 5, 6]]
<class 'list'>

下标索引

image-20230704110534622

image-20230704110628855

.index方法(由元素找到第一次出现的下标)

列表.index(元素)

Return first index of value.
Raises ValueError if the value is not present.(报错)

1
2
3
mylist = ["abc", "def", "ghi"]
idx=mylist.index("abc")
print(f'"abc"的下标位置为{idx}')
1
"abc"的下标位置为0

修改元素[]

1
2
3
mylist = ["abc", "def", "ghi"]
mylist[1]="bcd"
print(mylist)
1
['abc', 'bcd', 'ghi']

插入元素.insert()

1
2
3
mylist = ["abc", "def", "ghi", "jkl", "mno"]
mylist.insert(2, "666")
print(f"在下标2处插入元素后，mylist变成{mylist}")
1
在下标2处插入元素后，mylist变成['abc', 'def', '666', 'ghi', 'jkl', 'mno']

追加元素.append()

1
2
3
mylist = ["abc", "def", "ghi", "jkl", "mno"]
mylist.append("pqr")
print(f"在尾插元素后，mylist变成{mylist}")
1
在尾插元素后，mylist变成['abc', 'def', 'ghi', 'jkl', 'mno', 'pqr']

追加其他容器.extend()

1
2
3
mylist = ["abc", "def", "ghi", "jkl", "mno"]
mylist.extend(["pqr", "stu", "vwx"])
print(f"在追加列表后，mylist变成{mylist}")
1
在追加列表后，mylist变成['abc', 'def', 'ghi', 'jkl', 'mno', 'pqr', 'stu', 'vwx']

删除指定下标处元素

del 列表名[下标]或列表名.pop(下标)

1
2
3
4
5
mylist = ["abc", "def", "ghi", "jkl", "mno", "pqr", "stu", "vwx"]
del mylist[2]
print(f"删除元素后，mylist变成{mylist}")
element = mylist.pop(2)
print(f"取出{element}后，列表变成{mylist}")
1
2
删除元素后，mylist变成['abc', 'def', 'jkl', 'mno', 'pqr', 'stu', 'vwx']
取出jkl后，列表变成['abc', 'def', 'mno', 'pqr', 'stu', 'vwx']

找到并删除元素remove

1
2
3
mylist = [1, 2, 3, 2, 3]
mylist.remove(2)
print(mylist)
1
[1, 3, 2, 3]

只删除从左到右的第一个

清空列表.clear()

1
2
3
mylist = [1, 2, 3, 2, 3]
mylist.clear()
print(mylist)
1
[]

统计元素数量.count()

1
2
my_list = [1, 1, 1, 2, 3]
print(my_list.count(1))
1
3

列表长度

1
2
my_list = [1, 1, 1, 2, 3]
print(len(my_list))
1
5

image-20230704125810615

列表长度上限为263−1=92233720368547758072^{63}-1=9223372036854775807

遍历容器

1
2
3
my_list = [1, 2, 3, 4, 5, 6, 7, 8]
for ele in my_list:
    print(ele, end=" ")
1
1 2 3 4 5 6 7 8 
1
2
3
list1 = ["这", "是", "一个", "测试"]
for index, item in enumerate(list1):
    print(index, item)
1
2
3
4
0 这
1 是
2 一个
3 测试

可以设置下标从哪个数开始

1
2
3
list1 = ["这", "是", "一个", "测试"]
for index, item in enumerate(list1, 1):
    print(index, item)
1
2
3
4
1 这
2 是
3 一个
4 测试

拷贝容器.copy

l1=l2是深拷贝,修改l2,l1会跟着改变

l1-l2.copy()是浅拷贝,修改l2,l1不会跟着改变

6.7 tuple数据容器-元组

和list的区别是不可修改

定义:

(元素,元素,元素,......)

空元组:变量名称=()

变量名称=tuple()

1
2
3
# 定义单个元素的元组
t = ("hello")
print(f"类型是{type(t)},内容是{t}")
1
类型是<class 'str'>,内容是hello
1
2
3
4
# 定义单个元素的元组需要加一个逗号,以便和数学公式区分
t = ("hello",)
print(f"类型是{type(t)},内容是{t}")
print(len(t))
1
2
类型是<class 'tuple'>,内容是('hello',)
1

image-20230704140301050

元组不可修改,但元组中的列表可以修改

1
2
3
t = (1, 2, 3, 4, [1, 2, 3, 4], 5)
t[4][1] = -1
print(t)
1
(1, 2, 3, 4, [1, -1, 3, 4], 5)

6.8string数据容器-字符串

字符串可以通过下标进行访问

  • 从前往后,下标从0开始递增
  • 从后往前,下标从-1开始递减

同元组一样,字符串是一个无法修改的数据容器

index方法

1
2
s = "you are a handsome boy"
print(s.index("hand"))  # 返回hand第一次出现时h的下标
1
10

.replace方法(替换)

语法:字符串.replace(字符串1,字符串2)

功能:将字符串内的全部: 字符串1,替换为字符串2

注意:不是修改字符串本身,而是得到了一个新字符串

1
2
3
4
s = "cats and dogs are good cats and dogs and cats and dogs do things cats and dogs like do"
s1 = s.replace("cat", "tiger")
print(f"s={s}")
print(f"s1={s1}")
1
2
s=cats and dogs are good cats and dogs and cats and dogs do things cats and dogs like do
s1=tigers and dogs are good tigers and dogs and tigers and dogs do things tigers and dogs like do

.split方法(分割)

语法:字符串.split(分隔符字符串)

功能:按照指定的分隔符字符串,将字符串划分成多个字符串,并存入列表对象中

注意:字符串本身不变,而是得到了一个列表对象

1
2
3
4
s = "cats and dogs are good cats and dogs and cats and dogs do things cats and dogs like do"
l = s.split(" ")
print(f"s={s}")
print(f"s1={l},type(l)={type(l)}")
1
2
s=cats and dogs are good cats and dogs and cats and dogs do things cats and dogs like do
s1=['cats', 'and', 'dogs', 'are', 'good', 'cats', 'and', 'dogs', 'and', 'cats', 'and', 'dogs', 'do', 'things', 'cats', 'and', 'dogs', 'like', 'do'],type(l)=<class 'list'>

.strip方法(规整字符串)

image-20230704143727745

1
2
s = "12abcde1"
print(s.strip("12"))
1
abcde

.count方法统计字符串中某字符串出现的次数

1
2
s = "114514514114514514114114"
print(s.count("114"))
1
4

len统计字符串长度

1
2
s = "114514514114514514114114"
print(len(s))
1
24

汇总

image-20230704144414126

Python 中常用处理字符串的相关函数

原文链接

string.capitalize() 把字符串的第一个字符大写
string.count(str, beg=0, end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
string.endswith(obj, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
string.find(str, beg=0, end=len(string)) 检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
string.index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在 string中会报一个异常.
string.isalnum() 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
string.isalpha() 如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False
string.isdecimal() 如果 string 只包含十进制数字则返回 True 否则返回 False.
string.isdigit() 如果 string 只包含数字则返回 True 否则返回 False.
string.islower() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
string.isnumeric() 如果 string 中只包含数字字符，则返回 True，否则返回 False
string.isspace() 如果 string 中只包含空格，则返回 True，否则返回 False.
string.istitle() 如果 string 是标题化的(见 title())则返回 True，否则返回 False
string.isupper() 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
string.join(seq) 以 string 作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
string.lower() 转换 string 中所有大写字符为小写.
string.lstrip() 截掉 string 左边的空格
max(str) 返回字符串 str 中最大的字母。
min(str) 返回字符串 str 中最小的字母。
string.replace(str1, str2, num=string.count(str1)) 把 string 中的 str1 替换成 str2,如果 num 指定，则替换不超过 num 次.
string.split(str="", num=string.count(str)) 以 str 为分隔符切片 string，如果 num 有指定值，则仅分隔 num+ 个子字符串
string.startswith(obj, beg=0,end=len(string)) 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查.
string.strip([obj]) 在 string 上执行 lstrip()和 rstrip()
string.swapcase() 翻转 string 中的大小写
string.title() 返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
string.translate(str, del="") 根据 str 给出的表(包含 256 个字符)转换 string 的字符,要过滤掉的字符放到 del 参数中
string.upper() 转换 string 中的小写字母为大写

6.10(取子序列)序列的切片

序列:内容连续,有序,可使用下标索引的一类数据容器

列表、元组、字符串均可以视为序列

image-20230704145308052

注意:此操作不会影响序列本身,而是会得到一个新的序列

1
2
3
4
5
mylist = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
result1 = mylist[1:4]
result2 = mylist[2:9:2]
print(result1)
print(result2)
1
2
[1, 2, 3]
[2, 4, 6, 8]
1
2
3
4
5
mytuple = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
r1 = mytuple[:]  # 都不写表示从头到尾
r2 = mytuple[::-1]
print(f"r1={r1}")
print(f"r2={r2}")
1
2
r1=(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
r2=(10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)

6.12set集合

1
2
3
4
5
a = {1, 2, 3, 4, 5, 6, 1, 1, 1, 1, 1, 1, 11}
b = {}  # 注意:这里的b是字典而不是集合 
c = set()
print(a, b, c)
print(type(b))
1
2
{1, 2, 3, 4, 5, 6, 11} {} set()
<class 'dict'>

因为集合是无序的,所以不支持下标索引访问

但是集合和列表一样,是允许修改的

.add添加元素

1
2
3
4
a = {11, 2, 3, 4, 5, 6, 7}
a.add(1)
a.add(5)
print(a)
1
{1, 2, 3, 4, 5, 6, 7, 11}

.remove移除元素

1
2
3
a = {11, 2, 3, 4, 5, 6, 7}
a.remove(3)
print(a)
1
{2, 4, 5, 6, 7, 11}

.pop取出元素

1
2
3
4
5
6
a = {11, 2, 3, 4, 5, 6, 7}
while len(a) > 0:
    print(a.pop())
a = {"ab", "idq", "sq", "kq", "yc", "mw"}
while len(a) > 0:
    print(a.pop())
1
2
3
4
5
6
7
8
9
10
11
12
13
2
3
4
5
6
7
11
sq
yc
kq
mw
idq
ab

取出的过程对于字符串是随机的,即每次运行结果都不同

.difference集合差集

image-20230704163340854

.difference_update集合的差集并更新左集合

image-20230704163603047

.union集合合并

image-20230704163847187

集合长度

1
2
a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9}
print(len(a))
1
9

集合遍历

集合不支持下标索引,所以不能用while循环遍历集合

1
2
3
set1 = {1, 2, 3, 4, 5}
for ele in set1:
    print(ele, end=" ")
1
1 2 3 4 5

总结

image-20230704164456346

6.14 dict字典

1
2
3
4
5
6
d1 = {"a": 97, "b": 98, "c": 99, "d": 100}
print(f"d1={d1} with type{type(d1)}")
d2 = {}
print(f"d2={d2} with type{type(d2)}")
d3 = dict()
print(f"d3={d3} with type{type(d3)}")
1
2
3
d1={'a': 97, 'b': 98, 'c': 99, 'd': 100} with type<class 'dict'>
d2={} with type<class 'dict'>
d3={} with type<class 'dict'>

字典不允许键值重复

key和value可以是任意数据类型,但key不能为字典(必须可哈希)

[]访问元素

不可以使用下标索引,但可以根据key找到value

1
2
d1 = {"a": 97, "b": 98, "c": 99, "d": 100}
print(d1["b"])
1
98

[]新增元素,更新元素

image-20230704170925784

dict不支持访问不存在的元素(以下是错误代码)

1
2
d1 = {"a": 97, "b": 98, "c": 99, "d": 100, "e": 101, "f": 102}
print(f'd1["g"]={d1["g"]}')  # 代码编译错误

.pop删除元素

1
2
3
d1 = {"a": 97, "b": 98, "c": 99, "d": 100, "e": 101, "f": 102}
d1.pop("d")
print(d1)
1
{'a': 97, 'b': 98, 'c': 99, 'e': 101, 'f': 102}

.clear清空元素

1
2
3
d1 = {"a": 97, "b": 98, "c": 99, "d": 100, "e": 101, "f": 102}
d1.clear()
print(d1)
1
{}

.keys获取全部的key

1
2
3
4
d1 = {"a": 97, "b": 98, "c": 99, "d": 100, "e": 101, "f": 102}
k = d1.keys()
print(k)
print(type(k))
1
2
dict_keys(['a', 'b', 'c', 'd', 'e', 'f'])
<class 'dict_keys'>

遍历容器

方式1:通过key

1
2
3
4
d1 = {"a": 97, "b": 98, "c": 99, "d": 100, "e": 101, "f": 102}
k = d1.keys()
for k1 in k:
    print(f"key={k1},value={d1[k1]}", end=" ")
1
key=a,value=97 key=b,value=98 key=c,value=99 key=d,value=100 key=e,value=101 key=f,value=102

方式2:直接for循环

1
2
3
d1 = {"a": 97, "b": 98, "c": 99, "d": 100, "e": 101, "f": 102}
for k1 in d1:
    print(f"key={k1},value={d1[k1]}", end=" ")
1
key=a,value=97 key=b,value=98 key=c,value=99 key=d,value=100 key=e,value=101 key=f,value=102

len统计元素数量

1
2
d1 = {"a": 97, "b": 98, "c": 99, "d": 100, "e": 101, "f": 102}
print(len(d1))
1
6

判断元素是否在容器内

1
2
3
4
5
6
7
8
9
d1 = {"a": 97, "b": 98, "c": 99, "d": 100, "e": 101, "f": 102}
if "c" in d1:
    print("in")
if "p" not in d1:
    print("not in")
if 97 in d1.values():
    print("in")
else:
    print("not in")
1
2
3
in
not in
in

总结

image-20230704173113950

五类容器的总结

image-20230704173413765

image-20230704185950275

image-20230704190147277

万物皆可转列表(list)list{container}

1
2
3
4
5
6
7
8
a1 = (1, 2, 3, 4, 5)
b1 = "abcdefg"
c1 = {1, 2, 3, 4, 5}
d1 = {"a": 97, "b": 98, "c": 99, "d": 100, "e": 101, "f": 102}
print(list(a1))
print(list(b1))
print(list(c1))
print(list(d1))
1
2
3
4
[1, 2, 3, 4, 5]
['a', 'b', 'c', 'd', 'e', 'f', 'g']
[1, 2, 3, 4, 5]
['a', 'b', 'c', 'd', 'e', 'f']  %字典转列表只保留key

转tuple

1
2
3
4
5
6
7
8
a1 = (1, 2, 3, 4, 5)
b1 = "abcdefg"
c1 = {1, 2, 3, 4, 5}
d1 = {"a": 97, "b": 98, "c": 99, "d": 100, "e": 101, "f": 102}
print(tuple(a1))
print(tuple(b1))
print(tuple(c1))
print(tuple(d1))
1
2
3
4
(1, 2, 3, 4, 5)
('a', 'b', 'c', 'd', 'e', 'f', 'g')
(1, 2, 3, 4, 5)
('a', 'b', 'c', 'd', 'e', 'f')

转string

1
2
3
4
5
6
7
8
a1 = (1, 2, 3, 4, 5)
b1 = "abcdefg"
c1 = {1, 2, 3, 4, 5}
d1 = {"a": 97, "b": 98, "c": 99, "d": 100, "e": 101, "f": 102}
print(str(a1))
print(str(b1))
print(str(c1))
print(str(d1))
1
2
3
4
(1, 2, 3, 4, 5)
abcdefg
{1, 2, 3, 4, 5}
{'a': 97, 'b': 98, 'c': 99, 'd': 100, 'e': 101, 'f': 102}

转set

1
2
3
4
5
6
7
8
a1 = (1, 2, 3, 4, 5)
b1 = "abcdefg"
c1 = {1, 2, 3, 4, 5}
d1 = {"a": 97, "b": 98, "c": 99, "d": 100, "e": 101, "f": 102}
print(set(a1))
print(set(b1))
print(set(c1))
print(set(d1))
1
2
3
4
{1, 2, 3, 4, 5}
{'f', 'g', 'b', 'c', 'd', 'e', 'a'}  %被打乱了
{1, 2, 3, 4, 5}
{'f', 'a', 'b', 'c', 'd', 'e'}  %被打乱了

sorted通用排序功能

sorted(容器,[reverse=True]) 返回一个list

1
2
3
4
5
6
7
8
a1 = (5, 6, 2, 4, 0)
b1 = "bhwjdQNA1wq,"
c1 = {3,5,1,6,8}
d1 = {"d": 97, "c": 98, "q": 99, "r": 100, "l": 101, "x": 102}
print(sorted(a1))
print(sorted(b1))
print(sorted(c1))
print(sorted(d1))
1
2
3
4
[0, 2, 4, 5, 6]
[',', '1', 'A', 'N', 'Q', 'b', 'd', 'h', 'j', 'q', 'w', 'w']
[1, 3, 5, 6, 8]
['c', 'd', 'l', 'q', 'r', 'x']
1
2
3
4
5
6
7
8
a1 = (5, 6, 2, 4, 0)
b1 = "bhwjdQNA1wq,"
c1 = {3, 5, 1, 6, 8}
d1 = {"d": 97, "c": 98, "q": 99, "r": 100, "l": 101, "x": 102}
print(sorted(a1, reverse=True))
print(sorted(b1, reverse=True))
print(sorted(c1, reverse=True))
print(sorted(d1, reverse=True))
1
2
3
4
[6, 5, 4, 2, 0]
['w', 'w', 'q', 'j', 'h', 'd', 'b', 'Q', 'N', 'A', '1', ',']
[8, 6, 5, 3, 1]
['x', 'r', 'q', 'l', 'd', 'c']

sorted可指定排序的依据,参考https://blog.csdn.net/u010758410/article/details/79737498

1
2
listC = [('e', 4), ('o', 2), ('!', 5), ('v', 3), ('l', 1)]
print(sorted(listC, key=lambda x: ((x[1]-3)**2, -ord(x[0]))))

排序结果为

1
[('v', 3), ('o', 2), ('e', 4), ('l', 1), ('!', 5)]

排序一个数组，在排序的过程中另一个等长的数组的元素顺序也跟着改变:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 定义两个等长的数组
array1 = [3, 1, 4, 1, 5]
array2 = ['three', 'one', 'four', 'one', 'five']

# 使用 zip 将两个数组绑定，并按第一个数组排序
sorted_pairs = sorted(zip(array1, array2))

# 解压排序后的结果
sorted_array1, sorted_array2 = zip(*sorted_pairs)

# 将其转回列表形式
sorted_array1 = list(sorted_array1)
sorted_array2 = list(sorted_array2)

print("Sorted array1:", sorted_array1)
print("Sorted array2:", sorted_array2)

排序结果为

1
2
Sorted array1: [1, 1, 3, 4, 5]
Sorted array2: ['one', 'one', 'three', 'four', 'five']

7.1函数多返回值

1
2
3
4
5
6
def test01():
    return 11, 22


x, y = test01()
print(f"x={x},y={y}")
1
x=11,y=22
1
2
3
4
5
6
def test01():
    return 11, 4.5, "14"


x, y, z = test01()
print(f"x={x},y={y},z={z}")
1
x=11,y=4.5,z=14

7.2 函数的多种参数使用形式

位置参数

1
2
3
4
5
def test01(name, age, gender):
    print(name, age, gender)


test01('Tom', 10, '沃尔玛塑料袋')
1
Tom 10 沃尔玛塑料袋

关键字参数

1
2
3
4
5
def test01(name, age, gender):
    print(name, age, gender)


test01(name='Tom', age=10, gender='武装直升机')
1
Tom 10 武装直升机
1
2
3
4
5
def test01(name, age, gender):  # 可以打乱顺序
    print(name, age, gender)


test01(name='Tom', gender='武装直升机', age=10)
1
Tom 10 武装直升机
1
2
3
4
5
6
def test01(name, age, gender):
    print(name, age, gender)


test01('Tom', gender='武装直升机', age=10)  # 关键字参数可以和位置参数混用
# 要求位置参数必须在关键词参数前面,关键词参数之间不存在先后顺序
1
Tom 10 武装直升机

缺省参数

默认参数必须放在最后

1
2
3
4
5
def test01(name, age, gender="草履虫"):
    print(name, age, gender)


test01('Tom', 10)
1
Tom 10 草履虫

不定长参数

位置传递

1
2
3
4
5
6
7
def test01(*args):  # 所有参数都会被args变量收集,并形成一个元组tuple
    print(args)


test01('Jerry')
test01('Tom', 10)
test01('Trump', 77, 'Walmart bag')
1
2
3
('Jerry',)
('Tom', 10)
('Trump', 77, 'Walmart bag')

关键字传递

1
2
3
4
5
def user(**kwargs):  # 所有参数会被kwargs收集,并形成一个字典dict
    print(kwargs)


user(name='TOM', age=18, id=110)
1
{'name': 'TOM', 'age': 18, 'id': 110}

args -> arguments

kwargs -> key word arguments

7.3函数作为参数传递

1
2
3
4
5
6
7
8
9
10
11
def test_func(compute):
    result = compute(1, 2)
    print(result)
    print(type(compute))


def add(x, y):
    return x + y


test_func(add)
1
2
3
<class 'function'>

7.4 lambda匿名函数

lambda 传入参数: 函数体(一行代码)

1
2
3
4
5
6
7
def test_func(compute):
    result = compute(1, 2)
    print(result)
    print(type(compute))


test_func(lambda x, y: x + y)  # 可以不写return,默认是return
1
2
3
<class 'function'>

8.2 文件的读取

1
2
3
4
5
6
7
file_name = "input.txt"
with open(file_name, "r") as file:
    # 读取所有行, 得到一个字符串列表
    content = file.readlines()
    # 使用strip规整列表中的所有字符串，可以去掉字符串首尾的空格、换行符
    content = [s.strip() for s in content]
print(content)
1
['111111111111111111111111111111111111', '110000000001111111111111111000000001', '111111111111111111111111111111111111']

8.4文件的写出

1
2
3
4
5
6
# 打开文件
with open("hello.txt", "w", encoding="UTF-8") as file:
    # 写内容
    file.write("hello world")
    # 清空缓冲区，此步不是必须的
    file.flush()

9.4模块的概念和导入

image-20230705103353164

image-20230705103529040

1
2
3
4
5
import time  # 导入python内置的time模块（time.py这个代码文件）

print(1)
time.sleep(1)
print(2)
1
2
1
2

导入time模块后,就可以通过time.访问其中的内容(类,函数,变量)

1
2
3
4
5
6
from time import sleep  # 只导入time.py中sleep这一个函数

print(1)
# time.sleep(1)  # 报错
sleep(1)
print(2)
1
2
1
2
1
2
3
4
5
6
from time import *  # *表示导入time.py中所有函数

print(1)
# time.sleep(1)  # 报错
sleep(1)
print(2)
1
2
1
2
1
from functools import cache  # cache装饰器

给模块起别名

1
2
3
4
5
6
7
import time as tt  # 导入time.py中所有函数并起别名

print(1)
# time.sleep(1)  # 报错
# sleep(1)  # 报错
tt.sleep(1)
print(2)
1
2
1
2

给函数起别名

1
2
3
4
5
6
from time import sleep as sl  # 导入sleep函数命名为sl

print(1)
# sleep(2)  #报错
sl(2)
print(2)
1
2
1
2

9.5自定义模块

1
2
3
4
5
6
def print_hi(name):
    print(f'Hi, {name}')


if __name__ == '__main__':
    print_hi('PyCharm')

运行模块时会输出Hi, PyCharm

在其他文件导入模块时,不会输出Hi, PyCharm

image-20230721091434918

9.6 自定义python包

什么是Python包

从物理上看，包就是一个文件夹，在该文件夹下包含了一个__init__.py 文件，该文件夹可用于包含多个模块文件

从逻辑上看，包的本质依然是模块

导入包

方式一：

导入: import 包名.模块名

使用: 包名.模块名.目标函数

方式二:

导入: from 包名 import 模块名

使用: 模块名.目标函数

方式三:

导入: from 包名.模块名 import 目标函数

使用: 目标函数

方式四:

image-20230721093216149

9.7安装第三方包

什么是第三方包

我们知道，包可以包含一堆的Python模块，而每个模块又内含许多的功能。

所以，我们可以认为：一个包，就是一堆同类型功能的集合体。

在Python程序的生态中，有许多非常多的第三方包（非Python官方），可以极大的帮助我们提高开发效率，如：

  • 科学计算中常用的： numpy包

  • 数据分析中常用的：pandas包

  • 大数据计算中常用的：pyspark、apache-flink包

  • 图形可视化常用的: matplotlib,pyecharts

  • 人工智能常用的：tensorflow

  • 等

这些第三方的包，极大的丰富了Python的生态，提高了开发效率。

但是由于是第三方，所以Python没有内置，所以我们需要安装它们才可以导入使用哦。

安装第三方包 -pip

第三方包的安装非常简单，我们只需要使用Python内置的pip程序即可。

打开我们许久未见的：命令提示符程序，在里面输入：

pip install 包名称

即可通过网络快速安装第三方包

pip的网络优化

由于pip是连接的国外的网站进行包的下载,所以有的时候会速度很慢。

我们可以通过如下命令,让其连接国内的网站进行包的安装:

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名称

二.1.1类和对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class cla:
    a = None
    b = None
    c = None
    d = None


c = cla()
c.a = "abc"
c.b = 1
c.c = 114.514
c.d = True
print(c)
print(type(c))
print(c.a)
1
2
3
<__main__.cla object at 0x0000025DE9D36ED0>
<class '__main__.cla'>
abc

image-20230706124337439

image-20230706124628423

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class man:
    name = None

    def sayhi(self):
        print(f"我是{self.name}")

    def sayhi1(self, msg):
        print(f"我是{self.name},{msg}")


he = man()
he.name = "iurefbref"
he.sayhi()
he.sayhi1("hhhhhhh")
1
2
我是iurefbref
我是iurefbref,hhhhhhh

(python不支持函数重载)

1
2
3
4
5
6
7
8
9
def f1(a):
    print("a")


def f1(a, b):  # 覆盖上面的f1定义
    print("b")

f1(2)  # 报错
f1(2, 3)  # 正常

1.4构造方法

Python类可以使用：__init__()方法，称之为构造方法。

可以实现：

在创建类对象（构造类）的时候，会自动执行

在创建类对象（构造类）的时候，将传入参数自动传递给__init__方法使用。

1
2
3
4
5
6
7
8
9
10
11
12
class student:
    name = None
    age = None
    tel = None

    def __init__(self, name, age, tel):
        self.name = name
        self.age = age
        self.tel = tel


stu = student("张三", 31, "1145141919810")
1
2
3
4
5
6
7
8
9
class student:

    def __init__(self, name, age, tel):
        self.name = name
        self.age = age
        self.tel = tel


stu = student("张三", 31, "1145141919810")

这样写也是对的

1.5魔术方法

上文学习的__init__构造方法，是Python类内置的方法之一。

这些内置的类方法,各自有各自特殊的功能,这些内置方法我们称之为:魔术方法

  • __init__构造方法
  • __str__字符串方法, 控制类转换成字符串时的行为
  • __lt__小于,大于符号比较
  • __le__小于等于,大于等于符号比较
  • __eq__==符号比较

__str__方法(类似重载cout)

1
2
3
4
5
6
7
8
9
10
11
12
13
class student:

    def __init__(self, name, age, tel):
        self.name = name
        self.age = age
        self.tel = tel

    def __str__(self):
        return f"Student类对象, name = {self.name} , age = {self.age} , tel = {self.tel}"


stu = student("张三", 31, "1145141919810")
print(stu)
1
Student类对象, name = 张三 , age = 31 , tel = 1145141919810

__lt__方法(类似重载‘<’,’>’)

__lt__本质上是小于符号比较的(lower than),但它也能做到大于符号比较

写该函数时,只需返回一个bool变量,表示用小于符号时为true的条件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class student:

    def __init__(self, name, age, tel):
        self.name = name
        self.age = age
        self.tel = tel

    def __str__(self):
        return f"Student类对象, name = {self.name} , age = {self.age} , tel = {self.tel}"

    def __lt__(self, other):
        return self.age < other.age


stu1 = student("张三", 31, "1145141919810")
stu2 = student("里斯", 29, "1919810114514")
print(stu1 < stu2)
print(stu1 > stu2)
1
2
False
True

__le__方法(类似重载>=,<=)

less equal

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class student:

    def __init__(self, name, age, tel):
        self.name = name
        self.age = age
        self.tel = tel

    def __str__(self):
        return f"Student类对象, name = {self.name} , age = {self.age} , tel = {self.tel}"

    def __le__(self, other):
        return self.age <= other.age


stu1 = student("张三", 31, "1145141919810")
stu2 = student("里斯", 31, "1919810114514")
print(stu1 <= stu2)
print(stu1 >= stu2)
1
2
True
True

__eq__方法(类似重载==,!=)

equal

代码略

需要注意,对象自带比较==和!=的方法,当然只是比较内存地址是否相等

1.6封装

私有成员

既然现实事物有不公开的属性和行为，那么作为现实事物在程序中映射的类，也应该支持。

类中提供了私有成员的形式来支持。

  • 私有成员变量
  • 私有成员方法

定义私有成员的方式非常简单,只需要:

  • 私有成员变量:变量名以__开头(2个下划线)

  • 私有成员方法:方法名以__开头（2个下划线）

即可完成私有成员的设置

1.8继承

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class student:

    def __init__(self, name, age, tel):
        self.name = name
        self.age = age
        self.tel = tel

    def __str__(self):
        return f"Student类对象, name = {self.name} , age = {self.age} , tel = {self.tel}"

    def __le__(self, other):
        return self.age <= other.age


class dalao(student):
    GPA = 5.0


d1 = dalao("王五", 30, "114514")
print(d1.GPA)
1
5.0

多继承:

class 类名(父类1,父类2,...):

括号内越靠左,优先级越高(存在同名方法时)

复写

子类继承父类的成员属性和成员方法后，如果对其“不满意”，那么可以进行复写。

即:在子类中重新定义同名的属性或方法即可。

调用父类同名成员

一旦复写父类成员，那么类对象调用成员的时候，就会调用复写后的新成员

如果需要使用被复写的父类的成员，需要特殊的调用方式：

  • 方式1：调用父类成员

    • 使用成员变量:父类名.成员变量

    • 使用成员方法:父类名.成员方法(self)

  • 方式2:使用super()调用父类成员

    • 使用成员方法: super().成员方法()

    • 使用成员变量：super().成员变量

1.10变量的类型注解

类型注解

Python在3.5版本的时候引入了类型注解,以方便静态类型检查工具,IDE等第三方工具。

类型注解:在代码中涉及数据交互的地方,提供数据类型的注解(显式的说明)。

主要功能：帮助第三方IDE工具（如PyCharm）对代码进行类型推断，协助做代码提示

帮助开发者自身对变量进行类型注释

支持：

  • 变量的类型注解

  • 函数(方法)形参列表和返回值的类型注解

image-20230721115848877

image-20230721115923957

image-20230721120105365

按住需要用的函数和alt+enter可以自动搜索并导入包

类型注解是提示性的,而不是决定性的,以下的代码不会报错

1
2
var: int = "itheima"
print(var)
1
itheima

对于函数:形参注释

def 函数方法名(形参名: 类型, 形参名:类型, ...)->返回值类型:

union用法:

1
2
3
from typing import Union

my_list: list[Union[str, int]] = [1, 2, "itheima", "itcast"]

1.13多态

话不多说,上代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class animal:  # 成为抽象类
    def speak(self):
        pass  # 说明是空实现


class dog(animal):
    def speak(self):
        print("汪汪汪")


class cat(animal):
    def speak(self):
        print("喵喵喵")


class robot:
    def speak(self):
        print("滋滋滋")


def make_noise(ani: animal):
    ani.speak()


a = animal()
b = dog()
c = cat()
d = robot()
make_noise(a)
make_noise(b)
make_noise(c)
make_noise(d)
1
2
3
汪汪汪
喵喵喵
滋滋滋
programming language > python
python-notes
https://blog.algorithmpark.xyz/2023/07/23/language/python/index/
作者
CJL
发布于
2023年7月23日
更新于
2024年10月13日
许可协议