Python基础回顾笔记（一）-优快云博客

本文链接：https://blog.youkuaiyun.com/m0_55943142/article/details/143095953

格式化输出：

#输出：123 456
print("123","456)

+号使用：

左右两边都是数值型时，则做加法运算。
左右两边都是字符串时，则做拼接运算。

int类型：

int类型最大可以有4300个数字组成。

字节数随着数字的增大而增大（Python整型是变长的）。
每次的增量是4个字节。

float类型：

a = 0.1
a = .1   #0可以省略
a = 3.2e3 #表示3.2*10的3次方
a = 3.2e-3 #表示3.2/10的3次方

bool类型：

布尔类型也叫bool类型，取值为 True 和 False。
bool类型适用于逻辑运算，一般用于流程控制。
bool在运算中，True为1，False为0。
在Python中，非0值被视为真值，0值被视为假值

String类型:

使用引号（单双引号都可以）包括起来，创建字符串。
在字符串前面加 'r' 可以使整个字符串不会被转义。

类型转换：

隐式类型转换：在运算的时候，数据类型会向高精度自动转换。

显式类型转换：

运算符：

运算符的优先级：

三元运算符：

语法是：max = a if a > b else b

标识符的命名规则和命名规范:

类型使用大驼峰
常量一律大写

input()函数：

进制：

bin(x) 十进制转二进制

oct(x) 十进制转八进制

hex(x) 十进制转十六进制

位运算：

左移n位相当于乘2的n次方

右移n位相当于除2的n次方

for循环：

while循环：

函数：

内存处理流程：

函数注意细节：

如果同一个文件，出现两个函数名相同的函数，则以就近原则进行调用。
函数可以有多个返回值，返回数据类型不受限制—老韩解读（function_detail.py）

#比如函数接收两个数，返回这两个数的和、差
def f2(n1, n2):
return n1 +n2, n1 - n2
r1, r2 = f2(10, 20)
print(f'r1->{r1} r2->{r2)")

函数支持关键字参数，函数调用时，可以通过“形参名=实参值”形式传递参数，这样可以不受参数传递顺序的限制
函数支持默认参数/缺省参数-定义函数时，可以给参数提供默认值，调用函数时，指定了实参，则以指定为准，没有指定，则以默认值为准-默认参数，需要放在参数列表后。
函数支持可变参数/不定长参数-应用场景：当调用函数时，不确定传入多少个实参的情况-传入的多个实参，会被组成一个元组(tuple)，但是不确定是几个数时用*[0到多]

def sum(*args):
    sum1 = 0
    for i in args:
        sum1 += i
    return sum1
print(sum(1,2,3,4))

函数的可变参数/不定长参数还支特多个关键字参数，也就是多个“形参名=实参值”。当调用函数时，不确定传入多少个关键字参数的情况，传入的多个关键字参数，会被组成一个字典(dct)，可以使用关键字可变参数(**args)

def sum(**args):
    for arg in args:
        print("key:",arg,"value:",args[arg])
sum(name = "wkd",age = 19)

导入另一个文件的函数

import main
main.sum(name = "jmk",age = 18)

函数传参机制：

1、字符串与数值类型

字符串和数值类型是不可变数据类型，当对应的变量的值发生了变化时，它对应的内存地址会发生改变。

2、list，map，set类型

递归机制：

1、执行一个函数时，就创建一个新的空间（栈空间）

2、函数的变量是独立的，比如n变量

3、递归必须向退出递归的条件逼近，否则就是无限递归，就会出现RecursionError:maximum recursiondepth exceeded

4、当一个函数执行完毕，或者遇到return,就会返回，遵守谁调用，就将结果返回给谁

递归练习：

1、斐波那契数

def fbn(n):
    '''
    功能：求n对应的斐波那契数
    :param n:
    :return:
    '''
    if n == 1 or n == 2:
        return 1
    else:
        return fbn(n-1) + fbn(n-2)
print(fbn(7))  #13

2、猴子吃桃

猴子吃桃子问题：有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个！以后每天猴子都吃其中的一半，然后再多吃一个。当到第10天时，想再吃时（即还没吃），发现只有1个桃子了。问题：最初共多少个桃子？

def eat_peach(day):
    '''
    功能：第day天还剩n个桃子
    :param day: 第day天
    :return:桃子个数
    '''
    if day == 10:
        return 1
    else:
        return (eat_peach(day + 1) + 1) * 2

print(eat_peach(1))

lambda匿名函数

基本介绍如果我们有这样一个需求，需要将函数作为参数进行传递，但是这个函数只使用一次，这时，我们可以考虑使用 lambda匿名函数 1、函数的定义 def关键字，可以定义带有名称的函数，可以重复使用 lambda关键字，可以定义匿名函数（无名称），匿名函数只能使用一次匿名函数用于临时创建一个函数，只使用一次的场景 2、匿名函数基本语法 -lambda 形参列表：函数体（一行代码） -lambda关键字，表示定义匿名函数 -形参列表：比如num1,num2表示接收两个参数

全局变量：

全局变量：在整个程序范围内都可以访问，定义在函数外，拥有全局作用域的变量。

局部变量：只能在其被声明的函数范围内访问，定义在函数内部，拥有局部作用域的变量

在函数内部使用global关键字，可以标明指定使用全局变量

数据容器：

基本介绍 1、数据容器是一种数据类型，有些地方也简称为容器/collections 2、数据容器可以存放多个数据，每一个数据也被称为一个元素 3、存放的数据/元素可以是任意类型 4、简单的说，数据容器就是一种可以存放多个数据/元素的数据类型

各数据容器汇总：

数据容器特点比较

python的数据类型

不可变数据类型：数值类型(int、float)、bool(布尔)、string(字符串)、tuple(元组)
可变数据类型：Iist（列表)、set(集合)、dict(字典)

列表(list)、元组(tuple)属于序列类型：都支持通用序列操作方法。

列表(list)还支持可变序列操作。

字符串(str)也支持通用序列操作方法。

通用序列操作

在表格中，s 和 t 是具有相同类型的序列，n, i, j 和 k 是整数而 x 是任何满足 s 所规定的类型和值限制的任意对象。

运算	结果:
x in s	如果s中的某项等于x则结果为 True,否则为False
x not in s	如果s中的某项等于x则结果为False,否则为True
s + t	s与t相拼接
s * n 或 n * s	相当于s与自身进行n次拼接
s[i]	s的第i项,起始为0
s[i : j]	s从i到j的切片
s[i : j : k]	s从i到j步长为k的切片，i默认为0，j默认为字符串长度，k默认为1
len(s)	s的长度
min(s)	s的最小项
max(s)	s的最大项
s.index(x[ , i [ , j ] ])	x 在 s 中首次出现的索引（在索引 i 处或之后并且在 j 之前）
s.count(x)	x在s中出现的总次数

str.index ( substring [ , i [ , j ] ]) 等价于 str.index ( substring , i = 0 , j = len ( string ) )

可变序列操作

不可变操作：

主要是hash（）方法

通用转换操作

函数名	介绍
list( [ iterable] )	iterable可以是序列、支持迭代的容器或其它可迭代对象，也就是将指定的容器转成列表
str(容器)	将指定的容器转成字符串
tuple( [ iterable ] )	iterable可以是序列、支持迭代的容器或其他可迭代对象，也就是将指定的容器转成元组
set( [ iterable ] )	iterable可以是序列、支持迭代的容器或其他可迭代对象，也就是将指定的容器转成集合

列表：

列表的元素可以有多个，而且数据类型没有限制，同一列表可以有多种数据类型（但一般还是存放同一类数据类型），允许有重复元素，并且是有序的
索引也可以从尾部开始，最后一个元素的索引为-1，往前一位为-2，以此类推
通过列表[索引]=新值对数据进行更新，使用列表.append(值)方法来添加元素，使用deI语句来删除列表的元 素，注意能超出有效索引范围
列表生成器 [列表元素的表达式 for 自定义变量 i 可迭代对象] 实例： [ele*2 for ele in range(1,5)]=得到列表==>[2,4,6,8] 思考题： [ele+ele for ele in"韩顺平"]=得到列表==>['韩韩', '顺顺', '平平']

内存分布：

练习：

元组：

元组的定义：创建一个元组，只要把逗号分隔的不同的数据项，使用圆括号括起来即可，示例如下：

tuple a=(100,200,300,400,500)

元组是不可变序列（要注意其使用特点），允许重复，有序，看下面的代码：

tuple_1=(1,2.1,'韩顺平教育',[1,2,3])
# tuple_1[2]='python' #不能修改
tuple_1[3][1] = 3  #可以修改

定义只有一个元素的元组，需要带上逗号，否则就不是元组类型

tuple_1 = (1)  #<class 'int'>
tuple_1 = (1,)  #<class 'tuple'>

字符串：

在Python中处理文本数据是使用str对象，也称为字符串。字符串是由Unicode码位构成的不可变序列。

三种写法：

1)单引号：'允许包含有"双”引号 2)双引号："允许嵌入单引号" 3)三重引号："三重单引号"，"三重双引号"”，使用三重引号的字符串可以跨越多行一一其中所有的空白字符 都将包含在该字符串字面值中

切片语法：序列 [ 起始索引：结束索引：步长]，如果步长为负数，表示反向取，同时注意起始索引和结束索引也要反向标记

字符串支持通用序列操作方法。还额外提供了以下列出的一些附加方法(内置类型 — Python 3.11.10 文档)

函数名	介绍
len(str):	字符串的长度,也就是包含多少个字符
str. replace(old,new[,count])	返回字符串的副本,其中出现的所有子字符串old都将被替换为new。如果给出了可选参数 count,则只替换前 count次出现
str.split(sep=None,maxsplit=-1)	返回一个由字符串内单词组成的列表,使用sep作为分隔字符串。如果给出了maxsplit,则最多进行maxsplit次拆分(因此,列表最多会有maxsplit+1个元素)。如果 maxsplit未指定或为-1,则不限制拆分次数(进行所有可能的拆分)
str.count(sub)	统计指定字符串在字符串中出现的次数
str.index(sub)	从字符串中找出指定字符串第一个匹配项的索引位置
str.strip([chars])	返回原字符串的副本,移除其中的前导和末尾字符。chars为指定要移除字符的字符串 str.lower(): 返回原字符串小写的副本
str.upper()	返回原字符串大写的副本
str.lower()	返回原字符串小写的副本
>，>=，<，<=，==，!=	首先比较两个字符串中的第一个字符，如果相等则继续比较下一个字符，依次比较下去，直到两个字符串中的字符不相等时，其比较结果就是两个字符串的比较结果，两个字符串中的所有后续字符将不再被比较
str.capitalize()	返回原字符串的副本，其首个字符大写，其余为小写。
str.isalpha()	如果字符串中的所有字符都是字母字符且至少有一个字符，则返回 True，否则返回 False。
*str.join(iterable)*	以str作为分隔符，将iterable(一般为列表、元组、字符串、字典)所有的元素合并成一个新的字符串
str.center( width [ , fillchar] )	返回长度为 width 的字符串，原字符串在其正中。使用指定的 fillchar 填充两边的空位（默认使用 ASCII 空格符）。如果 width 小于等于 `len(s)` 则返回原字符串的副本。

集合：

不重复元素、无序 集合对象支持合集、交集、差集等数学运算
集合的定义创建一个集合，只要用逗号分隔的不同的数据项，并使用 { } 括起来即可
集合支持 x in set, len(set) 和 for x in set。
集合因为不支持索引取值，所以不支持while循环遍历
但作为一种无序的多项集，集合并不记录元素位置或插入顺序。所以不支持索引、切片或其他序列类的操作
创建空集合只能用set(),不能用{}，{}创建的是空字典，
集合生成式： { 集合元素的表达式 for 自定义变量 in 可迭代对象 } 实例： { ele * 2 for ele in range(1 , 5) } ==> 得到集合含有2,4,6,8这四个元素， 但是集合是无序的，所以不能保证元素的顺序一定是2,4,6,8

集合常用函数：

内置类型 — Python 3.11.10 文档

函数名	介绍
len(s)	s集合元素个数
x in s	检测x是否为s中的成员
add(elem)	将元素 elem 添加到集合中
remove(elem)	从集合中移除元素 elem。如果 elem 不存在于集合中则会引发 KeyError
pop():	从集合中随机移除并返回任意一个元素。如果集合为空则会引发 KeyError
clear():	从集合中移除所有元素
*union(others)**	返回一个新集合 , 其中包含来自原集合以及others 指定的所有集合中的元素，也就是两个集合的合集，等价于 s \| others
intersection(others)*	返回一个新集合，其中包含原集合以及 others 指定的所有集合中共有的元素，也就是两个集合的交集，等价于 s & others
difference(others)*	返回一个新集合，其中包含原集合中在 others 指定的其他集合中不存在的元素。也就是两个集合的差集，等价于 s - others

字典：

字典的定义：创建一个字典，只要把逗号分隔的不同的元素，用 { } 括起来即可，存储的元素是一个个的键值对，示例：dict_a [ key : value , key : value , key : value ....} ，取出：dict_a [key1]

字典的键可以是任意不可变类型，值可以为任意类型。

字典因为不支持索引取值，所以不支持while循环遍历

dict_b = {'one': 1, 'two': 2, 'three': 3}
for k, v in dict_b.items():
    print(k,v)

字典生成式基本语法：{ 字典key的表达式 : 字典value的表达式 for 表示key的变量，表示value的变量 in zip(可迭代对象，可迭代对象)

内置函数zip() 说明：zip()可以将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，返回由这些元组组成的列表

实例：

books=["红楼梦”，"三国演义"，"西游记"，"水浒传"]

authors=["曹雪芹"，"罗贯中"，"吴承恩"，"施耐庵"]

{book:author for book,author in zip(books,authors)}===>'红楼梦：曹雪芹，三国演义：罗贯中，西游记：吴承恩'，水浒传：施耐庵

字典常用函数：

函数名	介绍
len(d)	返回字典d中的项数
d[key]	返回d中以key 为键的项。如果映射中不存在key则会引发KeyError
d[key]=value	将 d[key]设为 value,如果key已经存在，则是修改value,如果key没有存在，则是增加key-value
del d[key]	将 d[key]从d中移除。如果映射中不存在 key 则会引发 KeyError
pop（key[，default]）	如果 key 存在于字典中则将其移除并返回其值，否则返回 default。如果default 未给出且key 不存在于字典中，则会引发KeyError
keys（）	返回字典所有的key
key in d	如果 d 中存在键 key 则返回 True,否则返回 False
clear（）	移除字典中的所有元素