Python入门笔记

最新推荐文章于 2021-10-27 17:25:06 发布

三寸雪

最新推荐文章于 2021-10-27 17:25:06 发布

阅读量1.7k

点赞数 19

分类专栏：笔记 python 文章标签： python

本文链接：https://blog.csdn.net/weixin_44339734/article/details/104083317

版权

笔记同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

python

1 篇文章 0 订阅

订阅专栏

在已具备其它语言基础下的笔记。

基于Python3.x

1.基础语法

文本编码

python3.x使用unicode编码，python2.x使用ASCII编码，二者的编码也可添加代码实现兼容。

语法风格：

采用缩进来代替{ }，相同缩进代表同一个代码块
一个tab键4个空格，一行语句不用tab与空格混用。
行末不加分号 ;

注释：

# 这是单行注释内容，规范写法#号和注释内容以一个空格相隔
a=3  # 这也是单行注释内容，规范写法#号也语句相隔至少两个空格
"""
这是多行注释内容：
双引号也可换成单引号
"""
# TODO(作者/邮件) 注释内容，表示这需要日后需要添加代码

算术运算符：

运算符	描述	实例
+	加	1+2=3
-	减	3-1=2
*	乘	1*2=2
/	除	1/2=0.5
//	取整	2/3=1
%	取余	2%3=2
**	幂	2**3=8

Python中*运算符还可以用于字符串运算，计算结果就是字符串进行若干次重复拼接。"字符串" * 3 = "字符串字符串字符串"

变量：

在python中，第一次出现的变量为定义变量，其它情况为使用变量，每个变量在定义后必须初始化，初始化赋值后该变量才会被创建。

变量名 = 变量值

变量类型

在Python中定义变量是不需要指定数据类型的，python解释器会自动根据变量值推导出变量的数据类型。

数据类型可分为数字型和非数据型

数字型：

int，float， bool(True/False)，complex

非数字型：

字符串，列表，元组，字典

使用type()函数可以查看一个变量的类型

变量命名规则：

由字母、数字和下划线组成
变量不以数字开头，区分大小写
不与python关键字相同
= 号左右各保留一个空格
每个单词都使用小写字母
单词与单词之间使用_下划线连接

前三点是语法规则，后三点是命名风格，更多python代码风格可网上查找

可使用命令查看python关键字import keyword print(keyword.kwlist)

不同变量类型直接的计算：

数字型变量之间可以之间计算，如果为bool型，True对应数字1，False对应数字0。
字符串变量之间可使用 + 拼接字符串
数字型变量和字符串变量可使用 * 进行某个字符串的重复拼接操作，除此之外，二者不能进行其它任何运算。

类型转化：

int(x)将x转换为整数

float(x)将x转换为浮点数

基本输入输出：

# 输入函数
# 双引号中可加入提示信息，Python认为用户输入的内容都为字符串
value = input("请输入信息:")

# 输出函数
# print函数自带回车
print("") # 输出换行
print("这行输出不换行", end="") # 输出后不换行
print(value)  #输出变量
print("输出字符串")

# 格式化输出
# 格式化字符%s,%d,%f，与c语言类似
a = 1
b = "str"
c = 0.1
print("这个变量%d是格式化输出" % a)
print("这两个变量%d%s是格式化输出" % (a,b))
print("%f" % (a*c)) # 若格式化字符对应的是一个表达式，必须加括号，括号内本质上是一个元组，后面的笔记中有。

2.分支跳转语句

if语句：

# 条件不需要用括号
# 条件中的逻辑运算用and，or，not代表与、或、非
if 条件1:
	执行语句1
elif 条件2:
	执行语句2
else:
    pass  # 这里的pass语句，相当于一个;表示空语句
# 类似于c中的三目运算负？的if-elif用法
变量 = 值1 if 条件 elif 值2  # 条件满足变量为值1，否则为值2

while语句

while 条件:
	pass #循环语句

for语句

# python的for语句与其它语言相比有很大的不同
# iterable_object是一个迭代对象，此for语句表示从迭代对象中依次取元素，至取尽
for iter_var in iterable_object:  
	suite_to_repeat	# 循环体

# for语句常和range()使用
range(start,end,step) # 返回一个迭代对象，表示从start（默认0）开始，到end(不包含)，步长为step(默认1)，的所有元素组成的迭代对象

# 例如
for i in range(3,11,2):
	print(i, end = " ") # 依次打印3，5，7，9
for i in range(5)	# 等价于range(0,5,1)
	print(i, end = " ") # 依次打印0, 1, 2, 3, 4

break和continue的用法于其它语言相同，有一点需要注意

break于else 连用

for 变量 in 集合
	pass
	if 条件:break
else:
    没有通 过break退出循环，循环结束后会执行的代码

3.函数

def 函数名(参数1,参数2=value,参数3=value):
    """文档注释"""
    函数体
  # 参数2和参数3中的value是缺省时的默认值，当调用函数传入参有多个缺省值时需要指定缺省参：数如:fun(a,参数3=b),fun(a,参数2=b)
  # 运行到该函数时可pycharm使用快捷键ctrl+q查看文档注释
    
def 函数名(参数a,*多值参数args,**多值参数kwargs):
	函数体
    # 多值参数接收元组类型数据，习惯上命名为args
    # kwargs可接收字典类型数据，习惯上命名kwargs

def fun(*args,**kwargs):
    函数体   
a=(1,2,3)
b={"name":张三}
fun(a,b)  # 解释器会把，a和b当作args的两个元素传递
fun(*a,**b)  # 解释器会自动拆包，把a和b分别赋值给args和kwargs

# 关键字参数调用法
def fun(x,y):
	pass

fun(y=1,x=5) # 等价于fun(5,1)即关键字参数调用可以不考虑参数顺序，但是必须写出所有参数

# 函数作为参数进行传递，类似于C中的函数指针

# lambda实现匿名函数
sum = lambda arg1, arg2: arg1 + arg2

res = sum(1,2) #返回值为3

'''
lambda只是一个表达式，函数体比def简单很多。
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。
'''

注：因为函数体相对独立，故应该在函数的上下方应用两个空行与其它代码分隔

当函数返回值是一个元组时，元组外的括号可以省略

可以用多个变量依次分别接收元组返回值中的元素，变量间以逗号分隔

4.模块和包

4.1模块

模块就像是一个工具包，类似于C语言中的头文件，想使用这个模块工具包需要用import语句导入。
每一个以扩展名py结尾的python源代码都是一个模块
import语句导入模块的时候不需要加上.py后缀

import 模块1 as 模块别名  # 建议大驼峰命名法
import 模块1,模块2
from 模块3 import 属性或方法  # 可直接使用，不需要加 模块3.
from 模块4 import *  #导入模块中的所有内容，但是不会提示同名冲突，易出现错误

模块别名.方法
模块别名.属性

当导入的模块存在同名冲突时，后导入的会覆盖原先的内容，若发生冲突可使用as赋予别名
python解释器会自动为被导入的模板文件用cpython进行编译，生成.cpy文件供CPU直接使用，以便加速模块中代码运行速度。
导入模块后解释器会先搜索当前目录是否存在模块，不存在之后才会搜索python的系统目录

使用__name__测试模块

当模块被导入后，所有没有缩进的代码都会被执行一次，因此如果模块中编写了某些测试代码，但是不希望在导入时执行就可以使用内置属性__name__

__name__是一个内置属性，记录着一个字符串
如果是被其它文件导入的，__name__就是模块名
如果是当前执行的程序，__name__就是__main__
因此可以同判断__name__的值来确定是否执行测试代码

# 导入模块
# 定义全局变量
# 定义类
# 定义函数

# 在函数的最下方
def test():
    pass

# 根据__name__的值判断是否调用测试函数
if __name__ == "__main__":
    test()

4.2包

包是一个包含多个模块的特殊目录，目录下有一个特殊的文件__init__.py，包名的命名方式与变量一致

要在外界使用包中的模块，需要在__init__.py中指定对外界提供的模块列表

from . import 模块1  # 从当前目录下导入模块
from 目录 import 模块2

4.3制作、安装和卸载模块

暂时用不到就没写

5.高级变量类型

5.1列表

List(列表)，类似于数组，但是元素可以是不同的数据类型
列表用[]定义，数据直接用,分隔。
下标从0开始

例：name_list=["zhangsan","lisi","wangwu"]

# List的定义和常用方法
list_one = []  # 空列表
list_two = [value1, value2 value3] # 非空列表

# 增
list_one.insert(index,value)  # 在指定位置插入数据
list_one.append(value)  # 在末尾追加数据
list_one.extend(list_two) # 将list_two的数据追加到list中
list_one+=list_two  # 与上一条语句等价，特殊点
# 查
list_one.index(value)  # 查找value在list中的索引
list_one[index]  # 查找指定index的元素值
# 改
list_one[index] = value  # 修改指定索引的值
# 删
list_one.remove(value)  # 删除出现的第一个值为value的元素
list_one.clear()  # 清空列表元素
list_one.pop(index)  # 删除index下标的元素，缺省时类似于出栈操作，删除列表最末尾的元素
del list_one[index]  # 删除index下标的元素，一般不使用

# 其它方法
len(list_one)  # 求列表元素个数
list_one.count(value)  # 查看value在list_one出现的次数
list_one.sort()  # 升序排序
list_one.sort(reverse=True)  # 降序排序
list_one.reverse()  # 将列表逆序

5.2元组

Tuple (元组)与List(列表)类似，不同之处在于元组的元素不能修改，表示多个元素组成的序列，一经定义不可修改。
元组中的元素可以是不同类型的
用()定义，数据直接使用,分隔。
下标从0开始
可以用多个变量依次分别接收元组返回值中的元素，变量间以逗号分隔，例如：a,b,c=(e,f,g)，其中括号可以省略

tuple_one = ("str", 1, 2.5)
tuple_two = ()  # 空元组
tuple_tree= (10,)  # 当元组只有一个元素时，要在末尾加逗号，否则会被python解释为int型
tuple_one[index]  # 取值
tuple_one.index(value)  # 取索引
tuple_one.count(value)  # 统计指定元素个数
len(tuple_one)  # 求元素个数

#格式化字符串中的元组，下方两个print函数等价
tuple_str = ("str",1.2.5)
print("%s%d%f" % ("str",1.2.5))
print("%s%d%f" % tuple)

列表和元素互转

list_one = list(tuple_one)

tuple_two = tuple(list_two)

5.3字典

字典是无序对象的集合，而列表是有序对象的集合
字典使用键值对存储数据，类似与java中的map
字典用{}定义，键值对直接使用,分隔
每个键值对由key（键）和value（值）组成，键、值间使用:分隔
键是唯一的，而值可以是任意类型任意值

dict_one = {"name":"张三","height":180,"weight:60"}
print(dict_one)  # 输出时是无序的
value = dict_one[key]  # 根据键取出值
dict_one[key] = value  # 修改字典中键为key的值为value,若不存在则新建键值对
dict_one.pop(key)  # 删除键为key的键值对
len(dict_one)  # 求键值对个数
dict_one.update(dict_two)  # 将dict_two中的键值对合并到dict_one中，若有重复则dict_two会覆盖原有键值对
dict_one.clear()  # 清空字典

5.4字符串

使用""或者''包含的文本为字符串
当字符串中需要使用到单引号和双引号的的时候，可以使用转义字符
当以""括起字符串的时候，字符串内容可以包含''，反之亦然

len(str)  # 求字符串长度
str_one.count(str_value)  # 统计子串的出现次数
str_one.index(str_value)  # 查找子串第一次出现的位置
# 字符串的方法有很多，可查阅开发文档

5.5公共方法

python内置函数

函数	描述	备注
len(item)	求元素个数
del(item)	删除变量	del后可加括号也可不加
max/min(item)	返回容器中最大/最小值	若是字典，只针对key比较

切片

list[index1:index2:dis]

tuple[index1:index2:dis]

str[index1:index2:dis]

三个参数依次代表切片的初始和结束下标和切片步长
区间采取左开右闭
参数可为负数，下标负数表示从末尾往前数，步长为负数表示从后往前切
字典不可用切片

运算符

运算符	python表达式	结果	描述	支持的数据类型
+	[1,2] + [3,4]	[1,2,3,4]	合并	字符串、列表、元组
*	[“str1”] * 3	[“str1”, “str1”,“str1”]	重复	字符串、列表、元组
in	1 in (1,2,3)	True	判断元素是否存在	字符串、列表、元组、字典
not in	0 not in (1,2,3)	True	判断元素是否不存在	字符串、列表、元组、字典
> >= == < <=	(1,2,3) < (2,2,4)	True	依次比较元素进而比较整个高级变量	字符串、列表、元组

in 和 not in 在对字典操作时判断的是键

in 和 not in被称为成员运算符

6.变量实质

6.1变量的存储和传递：

变量和数据分开保存在内存中
函数的参数传递及返回值都是引用传递
数据保存在内存中的一个位置，并标有地址
变量中保存着数据的地址，称引用
使用id()函数可查看变量中保存数据的所在地址
变量的赋值本质上是修改了变量保存的地址，即修改引用

例：a = 1数据1保存在内存中，把改内存的地址赋值给a

a = 2数据2保存在内存中，把该内存的地址赋值给a，原来1的地址没有变量引用。

6.2可变类型和不可变类型

不可变类型，内存中的数据不允许被修改

数字类型：int bool float complex
字符串：str
元组：tuple

可变类型，内存中的数据可以被修改

列表：list
字典：dict

字典中的key只能使用不可变类型的数据，字典中会调用hash函数返回哈希码，故key必须为不可变类型

可变类型的数据变化通过方法实现，实现后引用地址不变，但是数据发生了改变

若给一个可变类型的变量赋值一个新数据，变量引用会修改为新变量的引用

6.3局部变量和全局变量

局部变量：在函数内部定义和使用，临时保存函数内部数据

局部变量的生存周期：变量执行时才会被创建，函数执行结束后局部变量被系统回收

全局变量：函数外部定义的变量，所有的函数内部都可以使用这个变量

全局变量的生存周期：程序运行中始终存在

在使用局部和全局的同名变量时，局部变量优先于全局变量

在函数中不允许直接修改全局变量的引用，赋值语句会被解释为定义一个同名变量

可使用global声明变量为一个全局变量，在接下来的操作就是对全局变量进行操作

函数内使用全局变量，全局变量必须在函数调用前定义

代码结构示意图
shebang
import模块
全局变量
函数定义
执行代码

7.面向对象基础

1）定义类及创建对象

class 类名:
    def 方法1(self,参数列表):
        pass
    
    def 方法2(self,参数列表):
        pass
对象变量 = 类名()

类名的命名方法采用大驼峰命名法

self是调用该方法的对象的引用

在类外部可使用对象变量.新属性 = value给对象临时增加新的属性(不推荐使用)

2）内置函数与类属性和方法

python中对象几乎无处不在，变量、数据和函数都是对象。

__方法名__格式的方法是python提供的内置方法/属性

可使用内置函数dir(标识符/数据)查看对象对的所有属性和方法。

类内置函数init、del、str

class 类名:
    类属性 = value  # 定义在类名下方的表示类属性
    def __init__(self):  # 类似于其它语言构造函数
        self.属性1 = value  # 在初始化方法中新增的属性为所有类对象公共的属性
        self.属性2 = None  # None表示一个空对象，是一个特殊的常量，可以赋值给任意变量
    def __del__(self):  # 类似于c++的析构函数
        函数体
    def __str__(self):  # 当执行print(类变量)时会自动调用该方法，默认输出变量地址
        print("string")
   
# 在python中严格区分了类方法和静态方法
    @classmethod
    def 类方法(cls):  # cls相当于self
        pass
    
    @staticmethod
    def 静态方法():
        pass

当类属性与对象属性同名时，对象.属性 = value对象属性优先于类属性

类属性的访问类名/对象名.类属性，当采用对象.类属性=value时解释器会为对象增加一个同名的对象属性，而不影响类属性。

类方法，通过类名调用，可以访问类属性和类方法

静态方法，调用时并不需要传递类或者实例。静态方法很像我们在类外定义的函数，只不过静态方法可以通过类或者实例来调用而已。

3）身份运算符

身份运算符用于比较两个对象的**内存地址（引用）**是否一致

a is b判断两个标识符是不是引用同一个对象

a is not b判断两个表示放是不是引用两个不同对象

==运算符用于判断引用变量的值是否相等

4）私有属性和私有方法

# 在方法名或者属性名前加两个下划线__即表示私有
class 类名:
    def __init__(self):
        self.__a = value  # 属性__a即为私有属性
    
    def __secret(self):  # 方法__secret()即为私有方法                    
        pass

python中并无真正意义上的私有，python解释器实际上对私有名称做了修改
底层的实现即_类名 =》_类名__名称，可直接使用类变量._类名__名称访问私有数据。

8.单继承

class A:
    def f1():
        pass
    def f2():
        pass

class B(A):
    def f1():
        pass  # 可进行重写
    def f2():
        super().f2()  # 可调用父类的方法，等价于A.f1(self),不推荐

单一继承的特性和其它面向对象语言的语法类似

9.多继承

class A:
    def f1():
        pass


class B:
    def f2():
        pass

class C(A,B):
    pass

print(C.__mro__)  # 查看类C的方法搜索顺序
# (<class '__main__.C'>,<class '__main__.A'>,<class '__main__.B'>,<class '__main__.Object'>)  #输出内容

MRO方法搜索

Python中针对类提供了一个内置属性__mro__可以查看方法的搜索顺序，MRO（method resolution order），主要用于在多继承判断方法、属性时的调用路径。

按照__mro__方法的输出结果从左至右顺序查找
若找到一个方法就直接执行，不再搜索，否则往后一个类查找，直至结束还未查找到则报错

多态性

关于多态的内容与其它面向对象的语言一样。

10.异常

try:
    # 可能产生错误的代码
    e = Exception("异常提示信息")  #  执行print(e)时会打印该信息
    raise e  # 抛出异常
    pass
except 错误类型1:
    # 针对错误类型1的处理代码
    pass
except 错误类型2:
    # 针对错误类型2的处理代码
    pass
except Exception as result:  # 捕获未知异常错误，并赋值给result
    print(result)  # 可打印出异常信息
    pass
else:
    # 没有异常时会执行的代码
    pass
finally:
    # 无论有没有异常都会执行的代码
    pass

异常的传递，也称异常的抛出和捕获，当函数或方法执行出现异常，若在该方法或函数中没有捕获异常，系统会将异常传递给调用它的函数或方法。

若传递到主程序中仍没有异常处理，程序才会被终止。

python中提供了一个Exception异常类，可以创建一个异常对象，使用raise关键字抛出异常对象

11.文件读写操作

file = open("文件名","访问方式")  # open打开文件并返回文件对象，文件不存在则抛出异常，其实有第三个参数表示缓冲区大小(没提及)
# 更常用的自动捕获异常和关闭文件的做法
with open("文件名","访问方式") as file:
	file.read()  # 读操作
	file.write()  # 写操作
	file.close()  # 负责关闭文件
	file.readlines() # 读多行
	file.readline()  #读一行
	file.writelines(字符串序列) #写入多行
	file.seek(偏移量,起始)  # 移动文件指针，起始值有1，0，-1分别代表文件头，当前，文件尾

在用read读取文件的时候，有文件指针记录读取的位置

访问方式：

方式	说明
r	只读方式打开。默认模式，文件指针指向文件开头，文件不存在会抛出异常
w	只写方式打开。如果文件存在则会被覆盖，不存在则会创建新文件
a	追加方式打开。文件存在则文件指针会移动到文件末尾，不存在则创建新文件进行写入
r+	读写方式打开。文件指针指向文件开头，若文件不存在则抛出异常
w+	读写方式打开。文件存在会被覆盖，不存在则创建新文件
a+	读写方式打开。文件存在则文件指针放在文件的结尾，不存在则创建新文件进行写入

12.文件和目录的管理操作

在python中可以通过导入**os模块**执行常规的文件/目录管理操作，例如：创建、重命名、删除、改变路径、查看目录内容…

文件

方法名	说明	示例
rename	重命名文件	os.rename(源文件名,目标文件名)
remove	删除文件	os.remove(文件名)

方法名	说明	示例
listdir	目录或文件列表	os.listdir(目录名)
mkdir	创建目录	os.mkdir(目录名)
rmdir	递归删除目录	os.rmdir(目录名)
getcwd	获取当前目录	os.getcwd()
chdir	修改工作目录	os.chdir(目标目录)
path.isdir /isfile	判断是否是目录/文件	os.path.isdir(路径)

文件和目录都支持相对路径和绝对路径

三寸雪

关注

19
点赞
踩
60

收藏

觉得还不错? 一键收藏
4
评论
Python入门笔记

快速入门Python笔记1.基础语法2.分支跳转语句3.函数4.模块和包4.1模块4.2包4.3制作、安装和卸载模块5.高级变量类型5.1列表5.2元组5.3字典5.4字符串5.5公共方法6.变量实质**6.1变量的存储和传递：**6.2可变类型和不可变类型6.3局部变量和全局变量7.面向对象基础8.单继承9.多继承10.异常11.文件读写操作12.文件和目录的管理操作在已具备其它语言基础下的...
复制链接

扫一扫