Python测开28期-Camille-学习笔记-python基础

Camille · November 19, 2023, 5:19am

python基础
1.python和pycharm下载和安装

2.pycharm快捷键

Ctrl+F 搜索
Ctrl+R 替换
Ctrl+ / 注释
Ctrl+D 复制当前光标所在行代码
Ctrl+ G 跳转到指定行:列
Ctrl +Alt+L 格式化代码
Alt+Enter 问题修复
Ctrl（Alt)+shift+上下方向键上下移动光标所在行代码

3.编码规范

缩进：
在 Python 中，缩进是一种非常重要的语法规则，Python 使用缩进来确定代码的层次结构和执行顺序。

建议使用Tab键实现缩进
同一级别的代码块的缩进量必须相同

注释：

单行注释在 Python 中，使用# 作为单行注释的符号。注释从符号# 开始直到换行为止，其后面所有的内容都作为注释的内容而被 Python 解释器忽略。

#我是一段注释

多行注释在 Python 中，并没有一个单独的多行注释标记，而是将注释内容包含在一对三引号之间，这样的代码将被解释器忽略。由于这样的代码可以分为多行编写，所以也可以作为多行注释。

‘’’
可以使用
三单引号
实现
多行注释
‘’’

“”"
可以使用
三双引号
实现
多行注释
“”"

文档注释文档注释实际是多行注释的一种特殊使用形式，为 Python 文件、模块、类或者函数等添加版权、功能,说明等信息，例如，下面的代码将使用多行注释为程序添加功能、开发者、版权、开发日期等信息，也经常用来解释代码中重要的函数、参数等信息，利于后续开发者维护代码

命名规范

包名尽量短小，全小写字母，不推荐使用下划线
模块名尽量短小，全小写字母，可以使用下划线分隔多个字母
类名采用单词首字母大写形式，即 Pascal 风格。
常量命名时全部采用大写字母，可以使用下划线
变量、函数名也是全小写字母，多个字母间用下划线_进行分隔
使用单下划线_开头的模块变量或者函数是受保护的
使用双下划线__开头的实例变量或方法是类私有的列表条目

4.输入输出
input输入函数，从键盘获取输入数据，且输入的任何数据，都以字符串形式保存到程序中（加入提示信息更友好）。

输入函数 input()

s = input()
print(int(s) + 1)

数字字符串，无法进行计算(输入的任何数据，都以字符串形式保存到程序中)

msg = input(“请输入一段文本：”)
print(msg)

print输出函数，输出文本和变量。

输出一个数据

print(“Hello”)
print(123)

输出多个数据

print(“Hello”,“python”,1,2,3,4)

改变分隔符(指定分隔符)

print(1,2,3, sep=“–”)
print(1,2,3)

改变结束符

print(“Hello”,end=“”)
print(“World”,end=“–”)
print(“python”)

5.函数定义与调用
函数是一段可重复使用的代码块，它执行特定的任务并返回一个结果。
由函数名+参数+函数体+返回值组成
内置函数：预先定义好的实现特定功能的函数，可以直接使用，比如输入输出函数。
函数定义，满足实际开发需求
def function_name([parameter_list])
[‘’‘注释信息’‘’]
[function_body]
return[result]

函数定义

定义一个函数

def show():
“”" 这是一个显示函数，用来显示一段字符串 “”"
print(“Hello”)
print(“world”)
print(“python”)

函数调用
调用函数也就是执行函数。如果把创建函数理解为理解为创建一个具有某种功能的工具，那么调用函数就相当于使用该工具。

语法格式：

function_name([parameters_value])

函数调用

print(“第一次调用函数”)
show()
print(“第二次调用函数”)
show()
print(“第三次调用函数”)
show()
print(“程序执行完毕”)

注意：

程序在执行到函数调用时，会跳转到函数定义位置执行函数体中的代码。
函数体执行结束后，将返回到函数调用处继续向后执行其它代码。

6.标识符
标识符是用来标识变量、函数、类、模块和其他对象的名称。需要注意的是，在定义标识符的时候，虽然很自由，但是也不能随心所欲，合法的标识符需要遵从一定的规范。
见名知意，如： get_name 、is_select 、name 、age 等都是符合规则的标识符命名
不能使用关键字，如： if 、else 、for 、def 等等
区分大小写，如： hogwarts 和 Hogwarts 是两个不同的标识符。
标识符由英文字母、下划线_和数字组成，但不能以数字开头，如： hogwarts666 是合法的标识符，而 666hogwarts 则是非法的标识符

关键字
关键字是指在 Python 编程语言中具有特殊含义的保留单词。这些关键字被 Python 解释器用于识别程序的结构和语义，从而执行相应的操作。
在 Python 中，关键字不可以用作变量名、函数名或其他标识符的名称，否则会导致语法错误。

导入内置关键字模块

import keyword

打印所有的关键字

print(keyword.kwlist)

查看系统关键字

导入系统关键字

import keyword

定义一个用来获取系统关键字的函数

def get_keyword():
kw = keyword.kwlist
print(kw)
print((len(kw)))

调用执行函数

get_keyword()

[‘False’, ‘None’, ‘True’, ‘and’, ‘as’, ‘assert’, ‘async’, ‘await’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’,

‘elif’, ‘else’, ‘except’, ‘finally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’, ‘lambda’, ‘nonlocal’,

‘not’, ‘or’, ‘pass’, ‘raise’, ‘return’, ‘try’, ‘while’, ‘with’, ‘yield’]

35

变量
就是用来表示数据的名字
定义变量非常简单，只需将数据通过等号(=)赋值给一个符合命名规范的标识符即可。

name = "霍格沃兹"

变量的使用是指在程序中引用一个已经定义的变量
内置函数 id() 可以获取变量的内存地址，也就是这个变量在计算机内存中的唯一标识，通常是用一串数字表示
每个变量在内存中都有一个唯一的地址，通过比较两个变量的内存地址，可以判断它们是否是同一个变量。如果两个变量的内存地址相同，那么它们就是同一个变量

数据类型

基本数据类型
- Number（数字）
- String（字符串）
- bool（布尔类型）
复合数据类型（容器类型）
- List（列表）
- Tuple（元组）
- Dictionary（字典）
- Set（集合）
空类型
- None

为了方便检查一个变量的具体类型，可以使用 Python 内置的 type() 函数查看变量的类型
def type_info():
print(type(1))
print(type(“Hello”))
print(type(3.14))

n = 1
print(type(n))
n = " 1 "
print(type(n))

type_info()

数字类型

数字类型（Number) 包括整数(int)、浮点(float)数和复数(complex) 三个子类型

整数类型：用来表示整数数值，即没有小数部分的数值，在 Python 中，没有 Long 类型，统一使用 int 类型表示

浮点数

浮点类型：用来表示带小数点的数值，在 Python 中，没有 Double 类型，统一使用 float 类型表示。
复数类型：一般在数学和物理学中有广泛的应用，例如在电路分析、信号处理和量子力学中，在此了解即可

整数类型

def int_info():
n = 1
print(n)
print(type(n)) # <class ‘int’>

n = 987089479439434384938493893843489384343843434343434
print(n)
n = n + 1
print(n)
print(type(n))  # <class 'int'>

浮点型 float

def float_info():
n = 1.0
print(n)
print(type(n))

#f复数类型
def complex_info():
n = 4 + 3j
print(n)
print(type(n))

int_info()

float_info()

complex_info()

布尔类型

Python 中的布尔类型（bool）是整数类型（int）的一个子类，用来描述逻辑关系的正确与否。

布尔类型只有两个值，即 True 和 False 表示真和假，在 Python 中，布尔类型通常用于判断逻辑关系和状态标记。

条件判断

x = 5
y = 10
print(x < y)  # 输出True
print(x > y)  # 输出False

状态标记

程序开发过程中，经常需要标记一些状态，比如是否选中，是否点击等，都可以使用记录布尔值的变量记录状态。

isSelect = False
isExist = True

假值状态

在 Python 中，所有的对象都可以判断是否为真。其中，只有下面列出的几种情况得到的值为假，其他对象在 if 或者 while 语句中都表现为真。

常见的假值类型：

False
None
数值中的零，包括 0、0.0、虚数 0。
空序列，包括字符串、空元组、空列表、空字典。

def bool_info() → object:
print(1 > 2) # false
print(1 < 2) # True
# 标记对象
isSelect = True
isExist = False

isExist = True

print(isSelect)

if not {}:
print(“No”)
else:
print(“Yes”)

bool_info()

类型转换

Python 是动态类型的语言(也称为弱类型语言)，不需要像 Java 或者 C 语言一样必须在使用变量前声明变量的类型。虽然 Python 不需要先声明变量的类型，但有时仍然需要用到类型转换

自动转换

自动转换也称为隐式类型转换，程序在执行过程中自动完成，将数据精度低转换为数据精度高的类型。
有些时候，在对不同类型的数据进行运算时，Python 会自动将它们转成同样的类型，然后再计算结果。

强制转换

强制转换也称为显式类型转换，需要在代码中使用类型函数来转换。
比如通过 input() 函数获取的数字，实际为一个数字字符串，如果需要进行计算，需要将其转换成真正的数字才能进行数据计算。
如果我们不进行类型转换，那么可能会导致程序出现错误或者无法正常运行

int(x)：将 x 转换为整数。如果 x 是一个字符串，那么它必须是一个表示整数的字符串，否则将会抛出异常。
float(x)：将 x 转换为浮点数。如果 x 是一个字符串，那么它必须是一个表示浮点数的字符串，否则将会抛出异常。
complex(x)：将 x 转换为复数。如果 x 是一个字符串，那么它必须是一个表示复数的字符串，否则将会抛出异常。
bool(x)：将 x 转换为布尔值。如果 x 是一个空对象、0、空字符串、空列表、空元组、空字典或者 False，那么将返回 False，否则将返回 True。
str(x)：将 x 转换为字符串。如果 x 是一个对象，那么将会调用该对象的 str()方法，将其转换为字符串。
chr(x): 将一个整数转换为一个字符，虽然结果是一个字符，但其本质依然是一个字符串类型。

类型转换(自动类型转（隐式类型转换）、强制类型转换（显式类型转换））

隐式转换

import abc

def type_trans():
result = 10 + 3.14 # 自动将整型转变为浮点型进行计算，自从由精度低的向精度高的转化
print(result) # 13.14
print(type(result)) # <class ‘float’>

result = True + 1  # true作为1 进行计算为 2
print(result)
print(type(result))  # <class 'int'>

强制类型转换

data = input("请输入一个数字: ")

result = int(data) + 10 # 将data 强制转换成int 进行计算

print(result)

print(type(result))

print(float(1)) # 1.0
print(int(3.14)) # 3
print(int(3.74)) # 3
print(complex(3.74)) # (3.74+0j)
print(bool(3.74)) # True
print(bool()) # False
print(str(3.74)) # 3.74
print(chr(48)) # 0
print(type(chr(48))) # <class ‘str’>
print(chr(65)) # A
print(chr(97)) # a

type_trans()
如果在强制类型转换时，传递的转换数据不合法导致无法转换，那么将会抛出异常。

x = int("霍格沃兹")

执行后会提示：ValueError: invalid literal for int() with base 10: ‘霍格沃兹’。

运算符

Python 语言常用运算符如下:

算术运算符
比较（关系）运算符
赋值运算符
逻辑运算符
成员运算符
身份运算符
运算符优先级

这些运算符，根据使用操作数的不同，可分为：

单目运算符
双目运算符
三目运算符

在每一门语言中，运算符都是非常简单，但是非常重要，非常难以熟练掌握和灵活应用的知识点。

算术运算符

Python 中的算术运算符包括加法、减法、乘法、除法、取模和幂运算

运算符	描述
+	加法：两个操作数相加
-	减法：两个操作数相减
*	乘法：两个操作数相乘
/	除法：两个操作数相除，结果为浮点数类型
%	取模：也称为求余运算符，两个操作相除，取余数为计算结果
**	幂运算：返回x的y次幂
//	整除：两个操作数相除，取商，结果为整数类型

def clac_info():
# 加法 +
print(1 + 2)
print(10 + 200)
print(“Hello” + “World”)
print(“Hello” + str(1))

# 减法 -
print(20 - 19)
print(10 - 12)

# 乘法 *
print(2 * 3)
print(100 * 20)
print("Hello" * 3)
print(3 * "Hello")

# 除法 /

print(8 / 2)
print(9 / 2)
#  print(1 /0)

# 取模 （求余）

print(8 % 2)
print(9 % 2)
n = int(input("请输入任意数字:"))
print(n % 10 + 1)

# 整除 //

print(8 // 2)
print(9 // 2)
print(7 // 2)

# 幂运算符 **
print(2 ** 10)
print(2 ** 11)

clac_info()

赋值运算符

赋值运算符是使用 = 做为运算符号，将运算符左侧的数据或表达式的结果，保存到运算符左侧的标识符中。

在使用赋值运算符时，运算符右侧可以是任意类型的数据，但左侧必须是一个变量，否则会报错。

除普通的赋值运算符外，赋值运算符还可以和算术运算符组合成为复合赋值运算符。

Python 中提供的赋值运算符如下表所示：

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c = a 等效于 c = c a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c = a 等效于 c = c a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

赋值运算符

def ass_info():
# 赋值运算符 =
num = 2 + 3 * 5
print(num)
# 同时定义多个变量
a, b, c, d = 1, 2, 3333, 44
print(a, b, c, d)

复合赋值运算符

加法赋值运算符（+=）

num = 10
num += 20  # num=num +20
print(num)

减法赋值运算符（-=）

num = 10
num -= 20  # num=num -20
print(num)

幂赋值运算符（**=）

num = 10
num **= 20
print(num)

取整除赋值运算符（//=）

num = 10
num //= 20  # num=num //20
print(num)

乘法赋值运算符（*=）

num = 2
num *= 3+4   # num = 2*（3 +4） 算术和赋值运算符混合时，算术运算符优先级高于赋值运算符
print(num)

除法赋值运算符（/=)

num= 9
num /= 20
print(num)

ass_info()

关系运算符

关系运算符也称为比较运算符，用来对参与运算的两个操作数进行比较，确认两个操作数之间的关系，运算结果会返回一个布尔值

Python 中提供的关系运算符如下表所示：

运算符	描述
==	等于：比较对象是否相等
!=	不等于：比较两个对象是否不相等
>	大于：返回x是否大于y
<	小于：返回x是否小于y
>=	大于等于：返回x是否大于等于y。
<=	小于等于：返回x是否小于等于y。

关系比较运算符

def rela_info():
# 等于 ==
print(1 == 1) # True
print(1 == 2) # False
print(1 == “1”) # False
print(1 == “2”) # False
print(“abc” == “abc”) # True
print(“abc” == “ABC”) # False

# 不等于 !=
print(1 != 1)  # False
print(1 != 2)  # True
print(1 != "1")  # True
print(1 != "2")  # True
print("abc" != "abc")  # False
print("abc" != "ABC")  # True

# 大于 >
print(1 > 2)  # False
print(1 > 1)  # False
print(1 > 0)  # True
print("a" > "A")  # True
print("abc" > "ABC")  # True
print("aBC" > " Abed ")  # True
# print(1 > "a")     # True   不支持数值和字符串比较

# 大于等于 >=
print(1 >= 1)
print(1 >= 0)
print(1 >= 2)
# 小于
print(1 < 1)
print(1 < 2)

# 小于等于 <=
print(1 <= 1)
print(1 <= 0)
print(1 <= 2)

rela_info()

逻辑运算符

逻辑运算符一般用来解决当有多个关系条件需要判断时使用，用来确定这些条件组合的方式，运算结果为布尔类型值。

Python 中提供的逻辑运算符如下表所示：

运算符	逻辑表达式	描述
and	x and y	逻辑"与" ：如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。
or	x or y	逻辑"或" ：如果 x 是非 0，它返回 x 的计算值，否则它返回 y 的计算值。
not	not x	逻辑"非" ：如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。

短路特性

在使用逻辑与运算符和逻辑或运算符时，如果自左向右计算结果可以确定整个表达式的结果时，后面的表达式条件便不在计算。

非短路操作

result = True and print("Hello, World!1")  # 第一个操作数为True，不能确定后续都为真，所以print语句会执行
print(result)   # 输出 None，print语句的返回值为None

result = False or print("Hello, World!2")  # 第一个操作数为False，不能确定后续都为假，所以print语句会执行
print(result)  # 输出 None，print语句的返回值为None

短路操作

result = False and 1/0  # 第一个操作数为False，已经可以确认整个表达式的结果，虽然表达式有除0错误，但并不会执行
print(result)  # 结果为False

result = True or 1/0  # 第一个操作数为True，已经可以确认整个表达式的结果，虽然表达式有除0错误，但并不会执行
print(result)  # 结果为True

逻辑运算符

def logi_info():
# 逻辑与and
print( 1 > 0 and 2 > 0)
print(1 < 0 and 2 > 0)
print(1 > 0 and 2 < 0)
print(True and 5)

# 逻辑或 or
print(1 >0 or 2 >1)
print(1 <0 or 2 >1)
print(1 <0 or 2 <1)

print(4 or False)
print(False or "H")

# 逻辑非not
print(not True)
print(not False)

# 非短路操作
result = True and print("Python1")
print(result)
result = False and print("Python1")
print(result)

# 短路操作
result = False and 1/0
print(result)
result = 1 or 1 /0     # 只有一个为真，后面不会执行
print(result)

logi_info()

成员运算符

Python 提供了成员运算符，用于判断实例中是否包含了一系列的成员，包括字符串，列表或元组。

如下表所示：

运算符	描述
in	如果在指定的序列中找到值返回 True，否则返回 False。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。

身份运算符

Python 中的身份运算符用来判断两个对象的引用是否为同一个，换言之，就是用来比较两个对象的内存地址是否相同。

Python 对数字和字符串做了一些优化以提高性能和减少内存开销。以下是 Python 对数字和字符串做的一些优化：

整数池（Integer Pool）：Python 会在程序运行时预先创建一些整数对象，并将其保存在整数池中。这样，在创建整数对象时，可以重用已存在的对象，而不是创建新的对象。这在一定程度上减少了内存开销。
字符串池（String Pool）：对于较短的字符串，Python 会使用字符串池进行优化。字符串池是一个缓存区，保存着所有共享相同内容的字符串对象。当创建新的字符串对象时，Python 会首先检查是否已经存在相同内容的字符串对象，如果存在，则直接重用已有的对象，避免重复创建新的对象。

身份运算符如下表所示：

运算符	描述
is	is 是判断两个标识符是不是引用自一个对象
is not	is not 是判断两个标识符是不是引用自不同对象