Python从入门到精通

发布于：2025-06-19 ⋅ 阅读:(13) ⋅ 点赞:(0)

目录

Python的基本语法

逻辑结构

函数

列表

元组

字符串

切片操作

集合

字典

enumerate

文件

异常

模块和包

json和pyecharts

面向对象

连接mysql

Python的基本语法

定义变量的语法：

        a = 10

        a = b = c = 20

注释：

        #

        '''     '''

python在第一行可以指定文件的编码格式：#coding:gbk

数据类型：int, float, bool, str

输出系统的关键字

        import keyword

        print(keyword.kwlist)

查询对象所存储的内存地址：id(obj)

查询对象的数据类型：type(obj)

将其他数据类型转为字符串：str(obj)

将其他数据类型转为整数：int(obj)

将其他数据类型转为浮点数：float(obj)

格式化输出：

        print('name', 200, 30)

        print('我的名字是%s, 今年%d岁了' % (name, age))

输入：

        password = input('请输入你的密码：')

        print('你的密码是：' % password)

运算符：

        // 整除 num = 10 // 4

        ** 次方 num = 2 ** 5        

布尔运算符：

        not, and, or

        is:比较两个对象的内存地址是否相同 print(a is b)

        not is:两个对象的内存地址是否不相同 print(a not is b)

        in:一个字符串是否在另一个字符串里面 print('a' in 'abcd')

        not in:一个字符串是否不在另一个字符串里面 print('a' not in 'abcde')

系列解包赋值： a,b,c = 20,30,40   

位运算符： & | << >>

逻辑结构

获取对象的布尔值：bool(obj)

以下对象的布尔值为False，其他任何对象的布尔值都为True

        False

        数值0

        None

        空字符串，空列表，空元组，空字典，空集合

单分支结构的语法： 

        if 布尔表达式：

                python语句

双分支结构的语法：

        if n % 2:

                print('111')

        else:

                print('222')

多分支结构的语法：

        if score > 100:

                print('A')

        elif score > 90:

                print('B')

        elif score > 80:

                print('C')

        else:

                print('D')

三目运算：

        表达式1 if 条件 else  表达式2

        条件成立执行表达式1，不成立执行表达式2

pass语句，什么都不做，只是一个占位符

  • range()函数的使用：
    • 三种创建range对象的方式：  三个参数分别是：start，stop，step

r=range(10)  #创建一个[0,9]之间的整数序列，步长为1

print(list(r))  #打印内容

r=range(1,6)  #创建一个[1,5]之间的整数序列，步长为1

print(list(r))  #打印内容

r=range(1,20,3)  #创建一个[1,4,7....19]之间的整数序列，步长为3

print(list(r))  #打印内容

  • 返回值是一个迭代器对象
  • range类型的优点：不管range对象表示的整数序列有多长，所有range对象占用的内存空间都是相同的，因为仅仅需要存储start，stop和step，只有当用到range对象时，才会取计算序列中的相关元素
  • in与not in 可以判断整数序列中是否存在指定的整数
  • range(n)：会生成[0,n)的数据序列
  • range(a,b)：会生成[a,b)的数据序列
  • range(a,b,step)：会生成[a,b)的数据序列，步长为step
# while循环的使用：
sum=0
n=0

while  n<=100:
	sum+=n
	n+=1

print(sum)

# for-in循环的使用：
for  item  in  'python':
	print(item)

for  item  in  range(10):
	print(item)

item就是一个变量
#如果在循环体中不需要使用到自定义变量，可将自定义变量写为_
for  _  in  range(5):
	print('人生苦短，我用python')

# else和for循环和while循环的使用： 当循环不是被break语句退出时  才可以执行else中的语句
for  item  in  range(3):
	pwd=input('请输入您的密码：')
	if  pwd  ==  '8888':
		break
	else:
		print('密码错误，请重新输入！')
else:
	print('三次密码都输入错误，账号锁定')
	
n=3
while  n>0:
	pwd  =  input('请输入您的密码：')
	if  pwd  ==  '8888':
		break
	else:
		print('密码错误，请重新输入！')
	n-=1
else:
	print('三次密码都输入错误，账号锁定')

函数

# 函数的定义：函数可以嵌套定义函数
def 函数名(传入参数):	
    函数体 
    return 返回值

#函数的注释有特定的位置书写要求，要写在函数名字的下方

#查看函数的文档注释可以使用函数：help(函数名)

# 有参函数：
def add(a,b):	
    print(a + b)
		

# 想要在函数内部修改全局变量的值：
def fun1():	需要先用global声明这个变量为全部变量，才能修改
    global   n
    n = 200
  • 缺省参数：
    • 形参，在函数定义的时候，给形参一个默认值，这个形参就是缺省参数。
    • 注意点：缺省参数要写在普通参数的后边
    • 特点：在函数调用的时候，如果给缺省参数传递实参值，使用的是传递的是实参值，如果没有传递，使用默认值。
# 关键字传参，可以不按照参数的定义顺序传参
def fun7(name,age):
    print(name)
    print(age)

fun7(age=20,name='rose')

# 不定长参数：
# 在形参前边加上一个*，该形参变为不定长元组形参，可以接收所有的位置实参
# 在形参前边加上两个*，该形参变为不定长字典形参，可以接收所有的关键字实参
def fun(*args,**kwargs):	
    print(args)
    print(kwargs)
		        
fun(1,2,3,4,5)
fun(a=1,b=4,c=8)

# 函数没有返回值，默认返回None

# 函数返回多个值，返回值可以直接返回任何类型，以及多个数据，用逗号分隔即可
def fun6():	
    return 2,'666'
		
n1,str5 = fun6()
print(f'{n1}=={str5}')
		
# 函数作为函数参数

def test(add):
    sum = add(10,20)
    print(sum)
    
def add(n1,n2):
    return n1+n2

test(add)

# 函数的定义中
# def关键字，可以定义带有名称的函数
# lambda关键字，可以定义匿名函数(无名称)
# 有名称的函数，可以基于名称重复使用
# 无名称的匿名函数，只可临时使用一次
# 语法:
# lambda    传入参数: 函数体(一行代码)

def test(add):
    sum = add(10,20)
    print(sum)
test(lambda x,y: x + y)

列表

列表是python中的一种数据类型，可以存放多个数据，列表中的数据可以是任意类型的

列表list，定义使用[]

# 两种创建列表的方式：
list1 = ['hello',100,True];	
		
list2 = list([100,222.22,'world'])

# 获取列表的长度
list1 = [1,2,3]	
print(len(list1))

# 索引的范围：
# 正向索引从0到N-1
# 逆向索引从-N到-1
# 指定索引不存在，抛出IndexError
  • 列表的特点：
    • 列表元素按顺序有序排序
    • 索引映射唯一数据
    • 列表可以存储重复数据
    • 任意树类型混存
    • 根据需要动态分配和回收内存

  • 获取列表中指定元素的索引：obj.index()
    • 如查找列表中存在N个相同元素，只返回相同元素的第一个元素的索引
    • 如果查询的元素在列表中不存在，则会抛出ValueError
    • 还可以在指定的start和stop之间进行查找
  • 获取列表中的多个元素，切片操作：
    • 语法：  obj[start:stop:step]
    • 切片的结果： 原列表片段的拷贝
    • step默认为1：简写为  [start:stop]
    • step为正数：从start开始往后计算切片
      • [:stop:step]  切片的第一个元素默认是列表的第一个元素
      • [start::step]  切片的最后一个元素默认是列表的最后一个元素
    • step为负数：从start开始往前计算切片
      • [:stop:step]  切片的第一个元素默认是列表的最后一个元素
      • [start::step]  切片的最后一个元素默认是列表的第一个元素
# 列表的遍历
for item in obj	
    print(item)
  • 列表的添加操作：
    • append()：在列表的末尾添加一个元素，如果添加的是列表，添加的就是列表这一个元素
    • extend()：在列表的末尾至少添加一个元素，如果添加的是列表，添加的就是列表里面的全部元素
    • insert()：在列表的任意位置添加一个元素，当前位置以及以后的元素都后移一位
    • 切片，obj[1:] = ['hello',222] ：切片的数据只能是列表，添加后，原来位置以及后面的元素都会消失

  • 列表的删除操作：
    • remove(value)：一次删除一个元素，重复元素只删除第一个，元素不存在抛出ValueError
    • pop(index)：删除一个指定索引位置上的元素，指定索引不存在抛出IndexError，不指定索引，删除最后一个元素
    • 切片，obj[1:] = [] ：将指定下标以及之后的元素全部删除
    • clear()：清空列表
    • del ：del  list1[3]  删除元素
  • 列表的修改操作：
    • obj[1:3] = [100,200,300,400,500]：将列表下标[1,3)的数据全部替换为 后面的数据

  • 列表的查询操作
    • int index(value)：根据数据值，查找元素所在的下标，找到返回元素的下标，没有找到，程序报错
    • int count(value)：查询数据出现的次数
    • in：value in list1   存在则返回True

  • 列表的排序操作：
    • 调用sort方法，列表中所有元素默认按照从小到大的顺序进行排序，可以指定reverse=True，进行降序排序
    • 调用内置函数sorted()，可以指定reverse=True，进行降序排序，原列表不发生改变，new_list = sorted(list1)
# 列表的逆置：
list2 = list1[::-1]	

列表生成式：
list1 = [I * 2 for I in range(1,10)]

元组

  • 什么是元组：
    • Python内置的数据结构之一，是一个不可变序列
  • 创建元组的方式：
    • 直接小括号： t = ('Python',100,True)
    • 使用内置函数tuple()：t = tuple(('hello',11.11))
    • 只包含一个元组的元素需要使用逗号和小括号：t = (100,)
  • 为什么要将元组设计成不可变序列？
    • 在多任务环境下，同时操作对象时不需要加锁
    • 因此，在程序中尽量使用不可变序列
  • 元组中存储的是对象的引用：
    • 如果元组中对象本身不可变，则不能在引用其他对象。
    • 如果元组中的对象时可变对象，则可变对象的引用不允许改变，但数据可以改变。
# 元组的遍历：
t1=('python',100,True)	
		
for  item  in  t1:
    print(item)

字符串

# 字符串的定义
s1 = 'abc'	
s1 = "abc"	
s1 = """abc"""	
s1 = '''abc'''	

# 用下标访问字符
s1 = 'abcd'	
print(s1[2])

# 获取字符串的长度
s1 = 'abcddd'	
print(len(s1))
  • 字符串的常见操作
    • int find(sub_str,start,end):找子串 返回下标 找不到返回-1
    • int rfind(sub_str,start,end):从后面开始找子串 返回下标 找不到返回-1
    • int index(sub_str,start,end):找子串 返回下标 如果找不到就报错
    • int rindex(sub_str,start,end):从后面开始找子串 返回下标 如果找不到就报错
    • int count(sub_str,start,end):统计子串出现的次数
    • str replace(old_str,new_str,count):替换对应字符串，不改变原字符串，返回新的字符串，默认全部替换
    • 列表 split(sub_str,count):默认用空格切割，全部切割
    • 列表 rsplit(sub_str,count):从后面开始 默认用空格切割，全部切割
    • str join(str):当执行 '_'.join('hello')后 返回：h_e_l_l_o  每两个元素都插入一次

切片操作

  • 切片是对操作的对象截取其中一部分的操作
    • 切片的语法：变量[start:end:step]，会得到一个新的字符串
    • start：开始位置的下标
    • end：结束位置的下标，不包含end对应的下标
    • step：步长，下标之间的间隔，默认是1
    • start的位置也可以省略不写，表示是0
    • end的位置也可以不写，表示整个字符串的长度，但冒号不能省略

    • print(s1[::-1])

      字符串逆向输出

list1[:3]：取前三个数据

集合

  • 什么是集合？
    • Python语言提供的内置数据结构
    • 与列表，字典一样都属于可变类型的序列
    • 集合是没有value的字典
# 集合的创建：
set1={'pyhotn',100,True}

print(set1)
  • 集合的相关操作：
    • 集合元素的判断操作：
      • in 或 not in
    • 集合元素的新增操作：
      • 调用add()方法，一次添加一个元素
      • 调用update()方法，至少添加一个元素，如果添加的是列表，则添加的是列表中的元素
    • 集合元素的删除操作：
      • 调用remove()方法，一次删除一个指定元素，如果指定的元素不存在则抛出KeyError
      • 调用discard()方法，一次删除一个指定元素，如果指定的元素不存在，则不抛出异常
      • 调用pop()方法，一次只删除一个任意元素
      • 调用clear()方法，清空集合
  • 集合间的关系：
    • 两个集合是否相等：
      • 可以使用运算符 == 或 != 进行判断
    • 一个集合是否是另一个集合的子集
      • 可以调用方法issubset进行判断
      • B是A的子集
    • 一个集合是否是另一个集合的超集
      • 可以调用方法issuperset进行判断
      • A是B的超集
    • 两个集合是否没有交集
      • 可以调用方法isdisjoint进行判断
s1={10,20,30,40,60}
s2={10,20,30,99}

#交集
print(s1.intersection(s2))
print(s1&s2)

#并集
print(s1.union(s2))
print(s1|s2)

#差集
print(s1.difference(s2))
print(s1-s2)  #s1-(s1|s2)

#对称差集
print(s1.symmetric_difference(s2))
print(s1^s2)
# 集合的定义式：
s = {I * I for I in range(10)}
print(s)

字典

# 创建字典的两种方式：
scores={'张三':100,'李四':99,'王五':80}
print(scores)

d1=dict(name='张三',age=20)
print(d1)

# 字典中元素获取的两种方式：
scores={'张三':100,'李四':99,'王五':80}	
# []取值与使用get()取值的区别：
# []如果字典中不存在指定的key，抛出keyError异常
print(scores['张三'])	
# get()方法取值，如果字典中不存在指定的key，返回None
# print(scores.get('张三'))
  • 字典的增删改查操作：
    • 判断key是否存在： print('张三'   in   dict1)
    • 删除元素： del dict1['张三']
    • 添加元素： dict1['小王'] = 100
    • 清空字典：dict1.clear()

  • 获取字典视图的三种方式：
    • keys()：获取字典中所有key
    • values()：获取字典中所有value
    • items()：获取字典中所有key，value对
score={'张三':100,'李四':80,'王五':10}

for  item  in  score.keys():
	print(item)

for  item  in  score.values():
	print(item)

for  item  in  score.items():
	print(item)

for k,v in score.items():
	print(k,v)
  • 字典的特点：
    • 字典中的所有元素都是一个key-value对，key不允许重复，value可以重复
    • 字典中的元素是无序的
    • 字典中的key必须是不可变对象
    • 字典也可以根据需要动态的伸缩
    • 字典会浪费较大的内存，是一种使用空间换时间的数据结构
# 字典生成式
items=['Fruits','Books','Others']
prices=[100,50,90]

dict1={item:price   for  item,price  in  zip(items,prices)}
	print(dict1)

enumerate

list1 = ['a','b','c']
# 将可迭代对象所在的下标和具体元素组合在一起，变成元组
for i in enumerate(list1)
print(i)

文件

f = open(file='1.txt',mode='r',encoding='utf-8')
buf = f.read()
print(buf)
f.close()
  • 文件操作的三大步骤：
    • 1、打开文件，open()
    • 2、读文件 文件对象.read()
    • 3、关闭文件  文件对象.close()

  • 读文件操作
    • open(file,mode='r',encoding=None)
    • file，要操作的文件名字，类型是str
    • mode，文件打开的方式，r只读打开，w只写打开，a追加打开
    • encoding，文件的编码格式，常见的编码格式有两种，一种是gbk，一种是utf-8
    • 返回值，文件对象，后序所有的文件操作，都需要通过这个文件对象进行
  • 写文件操作
    • 1、打开文件方式用w，文件不存在，会创建文件，文件存在，会覆盖清空原文件
    • 2、写文件  文件对象.write(写入文件的内容)
    • 3、关闭文件
# coding=gbk
f = open('a.txt','w',encoding='utf-8')
f.write('你好')
f.close()
# 追加操作：
# coding=gbk
f = open('a.txt','a',encoding='utf-8')
f.write('hello world')
f.close()

# read(capacity)方法：参数为整形，读几个字节
# readLines()：按行读取，一次读取所有行，列表中的每一项是一个字符串，即一行的内容

# 读取大文件的方法：
# 按行读
# coding=gbk
f = open('a.txt','r',encoding='utf-8')
while True:
	buf = f.readline()
	if buf:
		print(buf,end='')
	else:
		break

f.close()

# 按字节读
# coding=gbk
f = open('a.txt','r',encoding='utf-8')
while True:
	buf = f.read(10)
	if buf:
		print(buf,end='')
	else:
		break

f.close()
  • 文件和目录的操作：
    • 对文件和目录的操作，需要导入os模块  import os
    • 1、文件重命名，os.rename(原文件路径名，新文件路径名)
    • 2、删除文件，os.remove(文件的路径名)

异常

# 捕获异常的代码：
try:
	可能出现异常的代码
except 异常类型:
	处理代码

# 捕获异常的代码：
try:
	可能出现异常的代码
except 异常类型:
	处理代码

# 捕获多个异常：
try:
	code
except (ZeroDivisionError,ValueError) :
	code

# 显示异常信息：
try:
	可能出现异常的代码
except ValueError as e:
	print(e)

# 捕获所有异常：
try:
	code
except Exception as e:
	code

# 异常的完整结构：
try:
	可能发生异常的代码
except Exception as e:
	发生异常执行的代码
	print(e)
else:
	代码没有发生异常，会执行
finally:
	不管有没有发生异常，都会执行

# 异常具有传递性：当所有函数都没有捕获异常的时候，程序就会报错

模块和包

# 使用模块的方法：模块就是一个python文件，就是一个工具包

import 模块名
模块名.功能名

from 模块名 import 功能名

from 模块名 import *

import 模块名 as 别名

from 模块名 import 功能名 as 别名


# 起别名，如果使用了as别名，就不能再使用原来的名字了
import my_module as mm1
  •  什么是包：
    • 功能相近或者相似的模块放在一个目录中，并在目录中定义一个__init__.py文件，这个目录就是包
# 如何导入包内的模块？
import 包名.模块名 as  别名	别名可有可无

# main函数
if __name__ == '__main__':
    print('main start')

# __all__ = ['fun1','fun2']
__all__出现在模块里，表示外部文件导入该模块时，只能使用列表里面的函数

json和pyecharts

  • 什么是json
    • json是一种轻量级的数据交互格式。可以按照json指定的格式取组织和封装数据
    • json本质上是一个带有特定格式的字符串
import json
data =  [{'name':'张三','age':11},{'name':'李四','age':20},{'name':'王五','age':15}]
print(data)
# 不使用ASCII码
data = json.dumps(data,ensure_ascii=False)
print(data)
data = json.loads(data)
print(data)
# https://gallery.pyecharts.org/#/  该网站用python代码画图  称为画廊

from pyecharts.charts import Line
line = Line()

line.add_xaxis(['中国','美国','英国'])

line.add_yaxis('GDP',[30,20,10])

line.render()

面向对象

# 创建类的方式：
class Dog(object):
	name = None
class Dog():
	name = None

class Dog:
	name = None


# 对象的创建，添加属性：
dog = Dog()
# 给对象添加属性
dog.name = '大黄'
dog.age = 20

# 修改属性值和添加一样，存在就是修改，不存在就是添加
dog.age = 2



# 类的行为：成员方法
class Student:
    name = None
    
    def say_hi(self):
        print(F'hi,{self.name}')
    
stu1 = Student()
stu1.name = '张三'

stu1.say_hi()
  • self：
    • 作为类中方法的第一个形参，再通过对象调用方法的时候，不需要手动的传递实参值，是python解释器自动将调用该方法的对象传递给self，所以self这个形参代表的是对象。
    • self就是一个形参的名字，可以写成其他的形参名，一般不修改这个名字。

  • 魔法方法
    • 在python的类中，有一类方法，这类方法以两个下划线开头和两个下划线结尾，并且在满足某个特定条件的情况下，会自动调用，这类方法，称为魔法方法。
  • __init__()成员方法作为构造方法使用：
    • 调用时机：在创建对象之后，会立即调用。
    • 1、用来给对象添加属性，给对象属性一个初始值(构造函数)
    • 2、代码的业务需求，都需要执行的代码可以写在这个方法中
    • 注意点：如果这个方法中，有除了self之外的形参，那么在创建对象的时候，需要给额外的形参传递实参值。

  • __str__()方法类似于toString()方法：
    • 调用时机：
      • 1、print(对象)，会自动调用__str__()方法，打印输出的结果是__str__方法的返回值
      • 2、str(对象)，类型转换，将自定义对象转换为字符串的时候，会自动调用
    • 应用：
      • 1、打印对象的时候，输出一些属性信息
      • 2、需要将对象转换为字符串类型的时候
    • 注意点：方法必须返回一个字符串
  • __lt__()方法用于比较两个对象的大小：
    • __le__()方法用于比较大于等于和小于等于
    • __eq__()方法用于比较是否等于
    • 重写该成员方法，自定义两个对象的比较条件
class Student:
    name = None
    age = None
    
    def __init__(self,name,age):
        self.name = name
        self.age = age
        
    def __lt__(self,other):
        return self.age < other.age
    
stu1 = Student('张三',20)
stu2 = Student('李四',30)

print(stu1 < stu2)
  • __del__()方法类似于gc机制：
    • 析构函数
    • 调用时机：
      • 对象在内存中被销毁删除的时候(引用计数为0)会自动调用__del__方法
      • 1、程序代码运行结束，在程序运行过程中，创建的所有对象和变量都会被删除销毁
      • 2、使用del 变量，将这个对象的引用计数变为0，会自动调用__del__()方法
    • 应用场景：
      • 对象被删除销毁的时候，要书写的代码可以写在__del__()中。
    • 引用计数：
      • 是python内存管理的一种机制，是指一块内存，有多少个变量在引用
      • 1、当一个变量，引用一块内存的时候，引用计数加1
      • 2、当删除一个变量，或者这个变量不再引用这块内存，引用计数减1
      • 3、当内存的引用计数变为0的时候，这块内存被删除，内存中的数据被销毁
  • 私有属性：
    • 只需要在原属性名前加上两个下划线
    • 目的：保证数据的相对安全
    • 想要访问和使用私有属性：定义get和set方法进行访问

  • 私有方法：
    • 在方法的前边加上两个下划线
    • 私有方法不能在类外部访问
    • 作用：一般作为类内部的方法使用，不让在外部直接调用
# 继承的基本语法
class Animal(object)
	代码
# Dog继承了Animal
class Dog(Animal)
	代码


# 想要在子类中调用父类的同名方法：
父类名.方法名(self,其他参数)

super().方法名()


# 多继承语法：
class A(B,C)	继承了B和C
    pass

class Student:
    name = None
    age = None

var: int = 10    
my_list: list = [1,2,3]
my_object: Student = Student()    

var_1 = 20 # type: int
ver_2 = 100 # type: int
# 在注释中使用注解

def fun(x: int,y: int):
    return x + y

print(fun(10,20))
# 在形参中使用类型注解

def fun2(data: list) -> list:
    return data

print(fun2([1,2,3]))
# 对返回值进行注解
  • 类方法：
    • 使用@classmethod修饰的方法，称为类方法，第一个参数为cls，代表的是类对象自己

  • 静态方法：
    • 使用@staticmethod修饰的方法，称为静态方法

什么是多态？

多态指的是，同一个行为，使用不同的对象获得不同的状态。

定义函数，通过类型注解声明需要父类对象，实际传入子类对象进行工作，从而获得不同的工作状态。

什么是抽象类？

包含抽象方法的类，称之为抽象类。抽象方法是指：没有具体实现的方法称为抽象方法

抽象类的作用？

多用于做顶层设计，以便子类做具体实现。

也是对子类的一种软性约束，要求子类必须复写父类的一些方法。

并配合多态使用，获得不同的工作状态。

连接mysql

from pymysql import Connection
#获取到mysql数据库的连接对象
conn=Connection(
	host='localhost',
	port=3306,
	user='root',
	password='1212'
)
#打印mysql数据库软件信息
print(conn.get_server_info())

#获取到游标对象
cursor=conn.cursor()
#选择数据库
conn.select_db('test')
#执行sql
#cursor.execute('createtabletest_pymysql(idint);')
cursor.execute('select*fromtab1')
result=cursor.fetchall()
print(result)
#cursor.execute("insertintotab1values(20,'rose');")
#提交事务
conn.commit()
#关闭到数据库的连接
conn.close()

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布