python基础
2023-03-09 17:59:07 8 举报AI智能生成
登录查看完整内容
为你推荐
查看更多
Python是一种高级编程语言，以其简洁易读的语法和强大的功能而受到广泛欢迎。它支持多种编程范式，包括面向对象、命令式、函数式和过程式编程。Python的设计哲学强调代码的可读性和简洁性，尤其是使用空格缩进划分代码块，而非使用大括号或关键字。Python的标准库非常庞大，可以支持很多任务，包括网页爬取、数据分析、机器学习等。此外，Python还拥有丰富的第三方库，可以应用于各种领域。Python的跨平台特性使其在Windows、Linux和Mac OS X上都能运行。总的来说，Python是一种强大且灵活的语言，适合初学者和专业开发者使用。
作者其他创作
大纲/内容
下载安装
将python的安装路径配置到环境变量中
检测：python --version
环境变量配置
Windows
默认安装
linux
安装编辑器
python环境部署
int
整型
float
浮点型
complex
复数
数字（Numbers）
str();数字字母下划线组成的一串字符
定义
从左到右索引默认0开始的
从右到左索引默认-1开始的
a!
str1 = 'aou! aou!'print(str1[0])print(str1[-1])
访问
aou! !!!!aou! aou!!!!!
print(str1[:5] + '!!!!')print(str1[:9] + '!!!!')
合并拼接字符串： 用“+”
str2 = \"\"\
>>>print(\"line1 \\... ... line2 \\... ... line3\")line1 ... line2 ... line3
\\在行尾 续行符
>>>print(\"\\\\\")\\>>>print(\"\\'\")'>>>print(\"\\\"\")\"
\\\\ 反斜杠、单引号 \\'、双引号\\‘’
转义字符 \\
end=''
结束符
input()
输入
>>>x = 1>>>f'{x+1}''2'>>>y=1>>>print(f'{y+1=}')y+1=2
使用表达式
替换变量
f-string
>>>print(mystr.title()) Process Finished With Exit Code 0
title()：首字母大写的方式显示每个单词，即将每个单词的首字母都改为大写
>>>mystr = \" process finished with exit code 0 \">>>print(mystr.lstrip())process finished with exit code 0
lstrip():删除左空白
>>>print(mystr.rstrip()) process finished with exit code 0
rstrip()
>>>print(mystr.strip())process finished with exit code 0
strip()
rstrip() 删除字符串尾部空格，临时删除，永久删除则需要存入变量中；lstrip() 删除字符串开头空格；strip()：删除两边空格
>>> str1 = 'process finished with exit code 0'>>> print(str1.find('with'))17
find() 查找，返回改字符串下标，否则返回-1
>>> print(str1.index('with'))17
index()，返回改字符串下标，没有报错
>>> print(str1.count('with'))1>>> print(str1.count('o'))2
count() 返回所查字符串的个数
str1.rfind('with')
str1.rindex('with')
C_str = str1.capitalize()
>>> str1 = 'process finished with exit code 0'>>> print(str1.startswith('p'))True
判断以某个字串开头startswith
>>> print(str1.endswith('0'))True
判断以某个字串结尾endswith
判断
常用方法
操作
字符串（String）
格式
列表结尾追加数据 语法 列表序列.append(数据) 如果追加数据是序列，则将整个序列追加至结尾处
append()
将字符串或列表数据拆开 加至列表结尾
extend()
列表.insert(位置下标，数据)
语法
insert()在指定索引处添加空间，并将插入的值存储到这个地方。这种操作将列表中既有的每个元素都右移一个位置
insert()
添加
print(name_list.index('Tom'))# #print(name_list.index('tom'))#数据不存在报错
index()
print(name_list.count('Tom'))print(name_list.count('Toms'))#数据不存在返回0
统计指定数据在当前列表中出现的次数（不存在返回0）
count()
访问列表长度 即列表中数据的个数
len()
查找
print('Tom' in name_list)
判断指定数据在某个列表序列 存在返回True 否则返回False
in
print('Tom' not in name_list)
判断指定数据不在某个列表序列 不存在返回True 否则返回False
not in
修改指定下标的数据
修改
del name_listdel(name_list)
del 目标 或者del(目标)
del name_list[2]
可删除指定下标数据
del
pop_name = name_list.pop()pop_name = name_list.pop(2)
删除指定下标数据 如未指定则删除最后数据
pop()
name_list.remove('Tom')
remove(数据)，删除匹配到的第一项
remove
name_list.clear()
清空列表
clear
删除
name_list.reverse()
逆序
reverse
升序 降序 默认升序
list1.sort(reverse=True)list1.sort(reverse=False)
sort
排序
print(name_list)i= 0while i <len(name_list): print(name_list[i]) i += 1
while
print(name_list)for i in name_list: print(i)
for
列表中遍历
遍历
start:起始索引，从0开始，-1表示结束 end：结束索引 step：步长，end-start，步长为正时，从左向右取值。步长为负时，反向取值
[start:end:step]
切片
list2 = name_list.copy()
copy（）
复制
列表嵌套
常用操作
列表（List）
定义使用（） 逗号隔开，数据可为不同数据类型
print(t1.index('bb'))print(t1.index('bba'))#不存在数据 报错
index（）
print(t1[0])
按下标查找
t2[2][0] = 'tom'
不可修改，元组中包含有可修改类型数据，如列表，则列表中数据可修改
del t1
元组中的元素值是不允许删除的，但可以使用del语句来删除整个元组
print(t1[4:0:-1])
print(len(t2))
访问列表长度 即元组中数据的个数
常见操作
元组(Tuple)
符号为花括号，数据为键值对形式出现，各个键值对之间用键值对隔开，字典为可变类型
特点
将一个字典添加到另一个字典
update
增
删除字典或者删除指定的键值对
del()/del
dict1.clear() # {}
清空字典
clear()
删
字典序列[key]=值
改
print(dict1['name']) # Tom
如果key存在则返回对应的值，不存在报错
key值查找
注意 如果当前查找的key不存在则返回第二个参数（默认值）如果省略第二个参数，则返回None
查找字典中所有的key 返回可迭代对象
keys()
查找字典中所有的值 返回可迭代对象
values()
返回所有的键值对，返回可迭代对象 里面数据是元组
items()
查
for key in dict1.keys(): print(key)
遍历key
for value in dict1.values(): print(value)
遍历value
for item in dict1.items(): print(item)
遍历键值对
嵌套
字典(Dictionary)
不允许重复数据 无顺序集合是可变类型
集合有去重功能 当追加数据是重复的则不进行任何操作
add()
追加的数据是序列
update()
删除集合中指定数据 如不存在报错
remove()
删除集合中指定数据 如不存在也不报错
discard()
del_num = s7.pop()print(del_num) # 40
随机删除集合中某个数据并返回该数据
print(10 in s7) # True
print(10 not in s7) # False
集合
数据类型
以字母或下划线开头的字母数字下划线组合
不能用关键字
区分大小写
命名规则
指变量生效的范围，分为局部变量和全局变量
定义在函数体内的变量 只在函数体内生效 在函数体内部 临时保存数据 函数调用完成后 则销毁局部变量
局部变量
函数体内外都能访问
100100200200200300
a = 100print(a)def testA(): print(a)def testB(): global a # 声明a是全局变量 global b b =300 a = 200 print(a)testA()testB()print(a)testA()print(b)
声明是全局变量，函数体内声明global a，在函数体外也能访问a
global
全局变量
变量作用域
变量
加+、减-、乘*、除/
>>>23//82->>>23//8-3
//
>>>23%87
%(返回出发的余数)
取模%、幂**、整除//（取商的整数部分，向下取整）
算数运算符
等于==、不等于！=、大于>、小于<、大于等于>=、小于等于<=
>>>3<=2False2>>>!=3True>>>1+1==2True
返回布尔型
比较运算符
>>>(1>2 and 3>2)False>>>1<2 and 3>2True
and:与，同时满足条件
>>>1>2 or 3>2True
or:或，至少满足一条
>>>not 1>2True>>>not 3>2False
not:非，条件为False，则返回True
逻辑运算符
=、+=、-=、*=、/=、%=、**=、//=
赋值运算符
在指定序列中找到指定之，返回True，否则返回False
>>>'s' not in 'se'False>>>'s' not in 'rg'True
在指定序列中没找到指定之，返回True，否则返回False
成员运算符
（）高于** 高于 * 、/、 //、 % 高于 +、 -
>>>True or False and FalseTrue>>>not True or False and FalseFalse>>>not False or False and FalseTrue
同优先级运算从左到右，逻辑运算符and 拥有更高优先级
运算符优先级
a = 1b = 2c = a if a > b else bprint(c)aa = int(input(\"输入aa:\"))bb = int(input(\"输入bb:\"))cc = aa - bb if aa > bb else bb - aaprint(cc)
条件成立执行的表达是 if 条件 else 条件不成立执行的表达式
三目运算符
运算符
单行注释 #
多行注释 三个引号（单引号或双引号）
注释
变量和运算符/注释
age = int(input('输入年龄'))if age >= 18 : print(\"可以上网\")else: print(\"未成年\")
if 语法if 条件：（注意缩进） 条件成立执行代码1 .。。elif 条件2: 条件2成立执行代码1 ...else: 条件都不成立执行语句代码 。。。。
if语法
money = int(input(\"1为有钱非1为无：\"))seat = int(input(\"1为有座非1为无：\"))if money == 1: print(\"上车\") if seat == 1: print(\"有空座\") else: print(\"无空座位\")else: print(\"不能坐车\")
if 条件1： 条件1成立执行代码 。。。 if 条件2： 条件2成立执行的代码
if嵌套语法
条件
i = 0while i < 5: print('减肥') i += 1
while 条件: 条件成立重复执行的代码
i = 1while i <= 5: if i== 4: print('吃饱') break print(f'吃了第{i}个苹果') i += 1
breaker 推出整个循环
j = 1while j <= 5: if j ==3: print('吃出个虫，这个不吃了') #continue前要执行要从修改计数器 否则会进入死循环 j += 1 continue print(f'吃了第{j}个苹果') j += 1
continue 当条件成立 退出当前一次循环，继续执行下一次循环
退出循环的方式
while 条件1: 条件1成立执行的代码 。。。 while 条件2： 条件2成立执行的代码 。。。
while循环嵌套
while
str1 = input(\"输入字符串：\")for i in str1: if i == 'e': break elif i== 'i': continue print(i)
for 临时变量 in 序列： 重复执行的代码1 重复执行的代码2
breaker 推出整个循环
continue 当条件成立 退出当前一次循环，继续执行下一次循环
循环
控制结构
def add_num1(): result = 1 + 2 print(result)
def 函数名（参数）： 代码。。。
定义函数
add_num1()
函数名（参数）
调用函数
定义的函数里允许调用者提供一些参数，就把这些参数写在括号里
形参
调用函数时 可不传默认参数
缺省参数（默认参数）
调用函数时根据函数定义的位置来传递参数
传递和定义参数的顺序和个数必须保持一致
位置参数必须写在关键字参数前面所有的位置参数必须在默认参数前，包括函数的定义和调用
位置参数
通过键=值的形式加以指定
关键字参数
传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组，*args 返回元组
包裹位置传递
收集所有的关键字参数，返回的是一个字典，无论是包裹位置还是包裹关键字传递，都是一个组包的过程
包裹关键字参数
不定长参数（可变参数）
参数
一个函数两个返回值
return 表示函数调用的结束并将结果返回至函数调用处
函数返回值
调用函数 解释器会回到定义函数的地方去执行函数体，定义的时候函数体没有被执行
先定义后调用
执行流程
函数体第一行 多行注释
help(sum_num)
查看
函数说明文档
def testB(): print('bbbbbbbb') return 1def testA(): print('aaaaaaaaaaaaa') testB() return print('end')testA()
函数嵌套调用
def sum_numbers(num): if num ==1: return 1 return num +sum_numbers(num-1)sumresult = sum_numbers(3)print(sumresult)
函数内部自己调用自己 必须有出口
递归
如果一个函数有一个返回值，并且只有一句代码，可以使用lambda简化
fn2 = lambda: 100print(fn2) # lambda内存地址 <function <lambda> at 0x030F8E80>print(fn2()) # 100
lambda 参数列表：表达式
参数形式
lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用 lambda表达式能接收任何数量的参数但只能返回一个表达式的值
注意
lambda
print(abs(-7)) # 7
求绝对值
abs()
print(round(1.2)) # 1print(round(1.6)) # 2
四舍五入
round()
map()
其中func必须有两个参数，每次func计算的结果继续和序列的写一个元素做累计计算
用于过滤序列，过滤不符合条件的元素，返回一个filter对象 如果要转换为列表，可以用list()来转换
常见函数
函数
name:文件名 可包括具体路径 mode：访问模式 只读 写入 追加
写法
-- w 写 文件不存在 新建文件 文件对象.write('内容') 覆盖原有内容
-- r 读 文件不存在报错 不支持write（） 访问模式省略 时 默认为 r
-- a 追加 如果文件不存在 则新建 write（） 在原有内容上追加
访问模式
打开文件
#print(f.read())# print(f.read(8))
read()
f.write('rr')
写操作
write（）
按照行的方式把文件内容进行一次性读取，并且返回的是一个列表，每一行的数据为一个元素
readlines()
一次读取一行内容
readline()
用来移动文件指针
seek()
文件重命名
os.rename(目标文件名，新文件名)
删除文件
os.remove(目标文件名)
获取当前目录
os.getcwd()
改变目录路径
os.chdir()
获取某个文件夹下所有文件 返回一个列表
os.listdir()
建文件夹
os.mkdir(文件夹名字)
删文件夹
os.rmdir(文件夹名字)
文件操作 os
文件处理
用来描述具有相同的属性和方法的对象的集合，定义了该集合中每个对象所共有的属性和方法
要满足标识符命名规则
简介
不去继承自己书写的类，默认级成所有类的顶级类 object ；其他类都叫派生类
print(Car.__doc__)
引号中，是类的说明，在类的第一行，通过.__doc__查看
class Car(object): ''' 车类 ''' odometer_reading = 0
odometer_reading是类变量，它的值能在这个类里面的所有实例间共享，可以通过Car.odometer_reading访问
类变量
__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法
__init__()
self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数
self
使用类的名称 Car来实例化，并通过 __init__ 方法接收参数
创建实例对象
my_new_car.read_odometer()
通过 . 来访问对象的属性
访问属性
my_new_car.age = 1my_new_car.age = 8del my_new_car.age
类属性只能通过类对象修改，不能通过实例对象修改，如果通过实例对象修改类属性，表示的是重新创键了一个实例属性
增加修改删除类的属性
类属性就是类对象所拥有的属性 被该类的有所实例对象所共有 类属性可以使用类对象或实例对象访问
记录的某行数据始终保持一致时，则定义类属性 实例属性要求每个对象为 其单独开辟一份内存空间来记录数据 类属性为全类所共有，仅占一份内存，更加节省内存空间
优点
需要用装饰器@classmethod来标识其为类方法，第一个参数必须是类对象，一般以cls作为第一个参数
类方法的特点
当方法中需要使用类对象（入访问私有属性等）是定义类方法 类方法一般和类属性配合使用
方法使用场景
类属性
类的创建，访问。。。
将属性和方法写到类里面，可以为属性添加私有属性
封装
#父类class A(object): pass# 子类class B(A): pass
指多个类之间的所属关系，及子类默认继承父类的所有属性和方法
创建子类时，父类必须位于子类前面
单一的继承关系，一个父类继承给一个子类
单继承
一个类同事继承了多个父类
当一个类有多个父类的时候，默认使用第一个父类的同名属性和方法
多继承
类别
子类和父类拥有同名属性和方法，用子类去创建对象，该对象调用同名属性和方法，调用的是子类里面封装的属性和方法
重写（子类重写父类同名属性和方法）
用父类方法，为保证调用到的是父类属性，必须在调用前调用父类初始化
子类调用父类同名方法和属性
关联父类子类
super(当前类名.self).函数名 父类中写super
多层继承中使用
super()
在方法属性前加 __
写法
对象不能访问私有属性和方法 子类无法继承父类的私有属性和私有方法一般定义get_XX、set_XX函数来获取和修改私有属性
私有属性
继承
一种使用对象的方式，子类重写父类的方法，调用不同的子类对象的相同父类方法，可以产生不同的执行结果
调用灵活，有了多态更容易编写通用的代码，做出通用的编程，以适应需求的不断变化
好处
定义父类，并提供公共方法 定义子类，并重写父类方法 传递子类对象给调用者，可以看到不同子类执行效果不同
实现步骤
多态
需要通过装饰器@staticmethod来进行修饰，静态方法既不需要传递类对象，也不需要传递实例对象（形参没有self/cls） 静态方法也能通过实例对象和类对象访问
静态方法特点
当方法中既不需要使用实例对象（如实例对象，实例属性），也不需要使用类对象（如类属性，类方法，创建实例属性）时，定义静态方法 取消不需要的参数传递，有利于减少不惜要的内存占用和性能消耗
静态方法的使用场景
静态方法
类
面向对象
try： code #需要判断是否会抛出异常的代码，如果没有异常处理，python会直接停止执行程序except: #这里会捕捉到上面代码中的异常，并根据异常抛出异常处理信息#except ExceptionName，args： #同时也可以接受异常名称和参数，针对不同形式的异常做处理 code #这里执行异常处理的相关代码，打印输出等else： #如果没有异常则执行else code #try部分被正常执行后执行的代码finally： code #退出try语句块总会执行的程序
try: 可能发生异常的代码except: 发生错误的时候执行的代码
try: 可能发生异常的代码 except 异常类型: 如果捕获到该异常类型执行的代码
捕获指定异常
捕获多个指定异常
捕获异常
try:<语句>finally:<语句> #退出try时总会执行
finally表示无论是否发生异常都要执行的代码
try-finally 语句
通过创建一个新的异常类，可以命名它们自己的异常
自定义异常
异常
每一个以扩展名.py结尾的Pyhton源代码文件都是一个模块，包含了 Python 对象定义和Python语句
import mathprint(math.sqrt(9))
import 模块名
导入模块
模块名.函数名
调用
from math import sqrt
从模块中导入一个指定的部分到当前命名空间中
print(sqrt(9))
不能使用模块名.函数名，直接使用函数名
from…import
from math import *
把一个模块的所有内容全都导入到当前的命名空间
from…import*
导入和使用
import time as tttt.sleep(2)print('hello')
定义了别名就不能再使用原模块名
import 模块名 as 别名
from time import sleep as slsl(2)print('hello')
定义了别名就不能再使用原函数名
from 模块名 import 函数 as别名
别名
import sysprint(sys.path)
模块搜索路径存储在 system 模块的 sys.path 变量中
变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录
搜索路径
自己文件名不要和已有文件名重复，否则导致模块功能无法使用
from time import sleep# def sleep(a):# print('自定义的')sleep(2)
使用from模块名 import 函数的时候，如果函数名字重复，调用到的是最后定义或者导入的函数
import time#print(time)time=1print(time)
变量也可以覆盖模块
重名
将有联系的模块组织在一起。即放到统一文件夹下，并且在这个文件夹创建一个名字为__init__.py文件（这个文件 用于标识当前文件夹是一个包，控制着包的导入行为）
import mypackage.my_module1mypackage.my_module1.info_print1()
import 包名.模块名
from mypackage import *my_module2.info_print1()
from 包名 import *
导入
模块名.目标
调用
包
模块
python基础
0 条评论
回复 删除
下一页
