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

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_nameis_selectnameage 等都是符合规则的标识符命名
不能使用关键字,如: ifelsefordef 等等
区分大小写,如: hogwartsHogwarts 是两个不同的标识符。
标识符由英文字母、下划线_和数字组成,但不能以数字开头,如: 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)的一个子类,用来描述逻辑关系的正确与否。

布尔类型只有两个值,即 TrueFalse 表示真和假,在 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 对数字和字符串做的一些优化:

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

身份运算符如下表所示:

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