Python 安装

官网open in new window

下载安装即可

验证是否安装成功

python 现在需要3.10版本以上即可

在cmd中直接输入
python有显示版本号就是可以的。

P7 Hello world

"""
在cmd中输入python 
后直接输入
"""
print("Hello world")
"""
输入
exit() 
可退出，注意需要添加双括号
"""

P10

"""
在cmd中
可以python xxx.py 文件
执行python文件
"""


shift+alt+上/下 将当前文件上移或者下移
ctrl+shift+f10 运行当前文件
shift+f6 重命名文件

P14 数据类型

数据类型

Numberint
float
complex
bool		整数
浮点数
复数不常用
布尔值
string字符串
List 列表有序的可变序列
Tuple 元组有序的不可变序列
Set 集合无序不重复的集合
Dictionary 字典无序 键值对

P15 注释


# 单行注释  # 号后加空格 规范

"""
多行注释
多行注释
"""

P16 变量


# 定义变量

# 变量名  = 变量值

a = 5
b = "string"

# 字符串连接 中间 可以用 ，
print("aaa",a,"元")

# 查看数据的类型
# 区别于变量类型  和数据的类型  变量是没有类型之说的

print(type(a))

# 字符串变量 表示 变量存储了字符串而不是表示变量就是字符串

P18 数据类型转换

int(x)     # 将x转为一个整数
float(x)   # 将x转为一个浮点数
str(x)     # 将x 转为一个字符串

P19 标识符

标识符

  • 变量名字
  • 方法名字
  • 类名字等

命名规范：

  • 包名：全部小写字母，中间可以由点分隔开，不推荐使用下划线。

  • 模块名：全部小写字母，如果是多个单词构成，可以用下划线隔开，如dummy_threading

  • 函数名应该为小写，可以用下划线风格单词以增加可读性。如：myfunction，my_example_function

  • 类名：总是使用首字母大写单词串。如MyClass。内部类可以使用额外的前导下划线

  • 异常名：异常属于类，命名同类命名，但应该使用Error作为后缀。如FileNotFoundError

  • 变量名：变量名：全部小写，由下划线连接各个单词。如color = WHITE，this_is_a_variable = 1

  • 不论是类成员变量还是全局变量，均不使用 m 或 g 前缀

  • 私有类成员使用单一下划线前缀标识，如_height。多定义公开成员，少定义私有成员

  • 总使用“self”作为实例方法的第一个参数。总使用“cls”作为类方法的第一个参数

P20 算法运算


2**2  =4   2的2次方
9//2  =4   9整除2 


# 复合赋值运算符

+=
-=
*=
/=
//=
%=
**=

P21 字符串

字符串定义


# 单引号
str = '我是一个字符串'
# 双引号
str = “我是一个字符串”
# 模板字符串
str= """
我是一个字符串，并且是一个模板字符串
我在这里面换行就是换行

"""

字符串的拼接

注意：字符串无法和非字符串类型进行拼接

a="我是一个字符串"
b="我也是一个字符串"
# 方式一 通过 + 号
print(a+b)
print(a,b)

字符串格式化


message  = "%s    %s" %("我这句话是对的",68)
print(message)

# 结果输出：
我这句话是对的    68



%s  将内容转换为字符串，放入占位位置
%d  将内容转换为整数，放入占位位置
%f  将内容转换为浮点数，放入占位位置


# 格式化方式二

"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
"{0} {1}".format("hello", "world")  # 设置指定位置
"{1} {0} {1}".format("hello", "world")  # 设置指定位置
    
  #   如果在字符串中需要直接展示花括号，则用另一个花括号包裹起来转义
     "{{我是谁}}:{}".format("皮卡丘")


# 格式化方式三

# 此种方式不会对数字进行精度化

name ="chen"
year = 2005
month = 6

result  = f"我是{name},今年是{year}"

print(result)

对表达式进行格式化




# 表达式：一条具有明确执行结果的代码语句

# 例如：

print("2*6的结果是：%d" %(2*6))
print(f"2*6的结果是：{2*6}")
print("字符串在python中的类型是：%s" % type("python"))

# 输出结果

2*6的结果是：12
2*6的结果是：12
字符串在python中的类型是：<class 'str'>

字符串格式化-数字宽度控制




 
# 用 m.n
# m 表示控制的宽度，要求是数字，设置的宽度小于数字本身，不生效
# n 表示小数点的精度，要求是数字，会进行小数的四舍五入

# 例如
"""
%5d 表示将整数的宽度控制在5位，如数字11 北设置为5d ,就会变成 [空格][空格][空格]11 ,用三个空格补足宽度
%5.2f 表示将宽度控制为5，将小数点精度设置为2
小数点和小数部分也算入宽度计算 如 11.345 设置了%7.2f 后，结果是  [空格][空格]11.35    2个空格补足宽度，小数部分限制2位精度后，四舍五入为.35
%.2f 11.345 -> 11.34


"""

输入函数

print("请输入数据")
data = input()
print(f"您输入的是{data}")

上面三句等同于下面两句

data = input("请输入数据")
print(f"您输入的是{data}")


# 结果窗口

请输入数据66
您输入的是66

流程 if-else


# python 对空格格数有非常严格的校验
# 代码块里面为4个空格

if 1 >= 2:
    print("ss")
elif 6<=3 :
    print("永远不会输出")
else:
    print("dd")
https://www.bilibili.com/video/BV1qW4y1a7fU?p=36&spm_id_from=pageDriver&vd_source=010173c6f35c758e74dd6593e5722af0

流程 while


while True:
    print("永远执行")

流程 for


# 语法
# 注意空格缩进

for 临时变量 in 待处理数据集(序列)
	循环满足条件时的代码

range 语句

序列类型是指，其内容可以一个个依次取出的一种类型，包括字符串，列表，元组等

range(num)从0开始，到num结束的数字序列（不含num本身）num(5)-> [0,1,2,3,4]
range(num1,num2)从num1,开始，到num，结束的数字序列（不含num本身）range(1,4)->[1,2,3]
range(num1,num2,setp)从num1,开始，到num，每次递增step.到结束的数字序列（不含num本身）range(1.9,3)->[1,4,7]

循环中断

continue : 暂时跳过某次循环，直接进行下一次
break :提前退出循环，不再继续；break 只在break 所在的最里面的for循环中提前退出循环，若外层还有for循环，外层循环不受break影响，

容器

# 列表 list
## 列表的定义，可以包括不同数据，规范：在逗号后有空格
name_list = ['小明', 3, True, ['列表嵌套']]
name_list.pop(0)
name_list.append('小李')
print(name_list)
## 定义空列表
name_list =[]
name_list=list()

## 列表的下标
## 从左往右
# 0,1,2,3 ...
##从右往左
#... ,-3,-2,-1
# num= name_list[100] # 超过下标范围会报错
#  IndexError: list index out of range
##取出嵌套列表的数据
name_list = [[1 , [1, 2, 3]]]
num = name_list[0][1][2]
print(num) # 3

## 列表常用方法

name_list = [1, 2, 3]

## 查询某元素的下标值

print("aa", name_list.index(3)) # aa 2

## 修改特定下标索引的值
name_list[0] = 999
print("aa", name_list[0] )

## 插入  参数：元素下标值，要插入的内容
name_list.insert(1, "小明")

## 在最后追加
name_list.append('小红')

## 在最后追加一批,逐个将name_list2的元素追加到name_list后面，而不是将整个list2 作为一个整体整体追加
name_list2 = ['aa','bb']
name_list.extend(name_list2)
print(name_list)

## 删除
## del 列表[下标索引值]
## 列表.pop(下标)
## 列表.remove("这是一个将被删除的元素") 指定元素删除 从左到右 第一个符合的被删除，如果右两个符合条件的，第二个不会被删除
## list.clear() 清空列表内容

del name_list[2]

## result 的值是 下标为2 的值，而不是列表的值
result = name_list.pop(2)

name_list.remove('小明')

## 统计列表内元素的个数
name_list.extend(["小明", "小明"])
result = name_list.count("小明")

## 统计列表内的个数
result = len(name_list)

## 元素转置
name_list.reverse()
print(name_list)





""" 
list 特点
可以容纳不同类型
数据有序
允许重复
可以修改

"""
## 列表的循环

for name in name_list:
    print(name)





# 元组 tuple
## 元组一旦当完成定义，就不可修改
## 有序，任意数量元素，各元素数据type 可不一样，允许重复元素
## 元组定义格式
## 定义元组字面量
## (元素  , 元素 ,)
"""

变量名称 =  (元素  , 元素 ,)
定义空元组
变量名称 = ()
变量名称 = tuple()

定义单个元素的元组

"""
# 字符串
name_tuple = ("小明")
# 元组
name_tuple = ("小红" , )
name_tuple = ()
# 计算元素的个数
num = len(name_tuple)




# 字符串 str

## 字符串操作

## 字符串也是一个只读的容器

str1 = "abcdefdfefefdsa"

## 分割
str_list =str.split("fe")
print(str_list)

## 去除前后的空格回车符
str1 = ' abb  \n'
str_new =str1.strip()
print(f"str_new:{str_new}")


## 序列切片

## 从序列中取出子序列即切片


"""
序列[起始下标:结束下标：步长]

结束下标(不含)表示何处结束，可以留空，留空视为截取到结尾

序列操作不会影响序列本身，会得到一个新的序列

"""
name_list =[0,1,2,3,4,5,6,7,8,9,10]
# 步长为1，从1开始取，到下标为4(不含下标4)
name_list[1:4]
# 跟原来的name_list一样的
name_list[:]
# 步长为4 ，
name_list[::4]
# 从后往前取
name_list[::-1]









# 集合 set

## 无序，

## 集合为 { }


a = {8, 9, 8}
b = {9, 10, 11, 9}
# 空集合 注意空集合 没有  {} {}是代表字典
empty =set()
## a集合和b 集合 合并
a.union(b)
## 差集
result = a.difference(b)
## 集合a 去掉差集两个集合的差集的内容
a.difference_update()


#a.discard()

## 返回集合的交集

a.intersection()
## 返回集合的交集 并将a 设置为交际
#a.intersection_update()

#a.isdisjoint()
#a.issubset()
#a.issuperset()
#a.update()
#a.symmetric_difference()
#a.symmetric_difference_update()




# 字典 dict


## 字典的定义

## 字典和集合 同样 也是用 大括号 但是不同的是存储的元素是一个个的键值对
## 如果有重复的key ,则后面的key会覆盖前面的key

name_dict = {1: 3, 2: 3, 3: 3, 4: 40, 1: 20}

name_dict={}
name_dict=dict()






## 字典的相关操作


tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}

del tinydict['Name']  # 删除键 'Name'
tinydict.clear()  # 清空字典
del tinydict  # 删除字典

# dict.items()

# !/usr/bin/python3

tinydict = {'Name': 'Runoob', 'Age': 7}

print("Value : %s" % tinydict.items())
## 以上实例输出结果为：

## Value: dict_items([('Age', 7), ('Name', 'Runoob')])

##Python 字典 update() 函数把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里。
## dict.update(dict2)

# !/usr/bin/python3

tinydict = {'Name': 'Runoob', 'Age': 7}
tinydict2 = {'Sex': 'female'}

tinydict.update(tinydict2)
print("更新字典 tinydict : ", tinydict)
# 以上实例输出结果为：

#更新字典
## tinydict: {'Name': 'Runoob', 'Age': 7, 'Sex': 'female'}

## 遍历

## for循环的两种方式
tinydict_key = tinydict.keys();
for i in tinydict_key:
    print(i)
    print(tinydict[i])

for key in tinydict:
    print(key)
    print(tinydict[key])


# 字典不支持下标索引



# 容器的通用操作

# 长度，最大的元素，最小的元素
#len(name_list)
#max(name_list)
#min(name_list)


# 类型转换 容器转列表
contain1 = "str"
contain2 = ['str','abc']
contain3 = ('str','efg')
contain4 = {'a','b'}
contain5 = {1:3,2:3,3:3}
print(f"转换结果为:{list(contain1)}")
print(f"转换结果为:{list(contain2)}")
print(f"转换结果为:{list(contain3)}")
print(f"转换结果为:{list(contain4)}")
print(f"转换结果为:{list(contain5)}")

"""
转换结果为:['s', 't', 'r']
转换结果为:['str', 'abc']
转换结果为:['str', 'efg']
转换结果为:['b', 'a']
转换结果为:[1, 2, 3]
"""

# 类型转换 容器转元组
print(f"转换结果为:{tuple(contain1)}")
print(f"转换结果为:{tuple(contain2)}")
print(f"转换结果为:{tuple(contain3)}")
print(f"转换结果为:{tuple(contain4)}")
print(f"转换结果为:{tuple(contain5)}")

"""
转换结果为:('s', 't', 'r')
转换结果为:('str', 'abc')
转换结果为:('str', 'efg')
转换结果为:('b', 'a')
转换结果为:(1, 2, 3)

"""

# 类型转换 容器转字符串
print(f"转换结果为:{str(contain1)}")
print(f"转换结果为:{str(contain2)}")
print(f"转换结果为:{str(contain3)}")
print(f"转换结果为:{str(contain4)}")
print(f"转换结果为:{str(contain5)}")

"""
看着像各自的类型，其实已经是字符串了
"转换结果为:['str', 'abc']"
"转换结果为:('str', 'efg')"
"转换结果为:{'b', 'a'}"
"转换结果为:{1: 3, 2: 3, 3: 3}"
"""

# 类型转换，容器转集合
print(f"转换结果为:{set(contain1)}")
print(f"转换结果为:{set(contain2)}")
print(f"转换结果为:{set(contain3)}")
print(f"转换结果为:{set(contain4)}")
print(f"转换结果为:{set(contain5)}")


# 容器通用排序功能

#
# sorted(容器,[reversed])
# 排序完之后变成列表
print(f"排序转换结果为:{sorted(contain1)}")
print(f"排序转换结果为:{sorted(contain2)}")
print(f"排序转换结果为:{sorted(contain3)}")
print(f"排序转换结果为:{sorted(contain4)}")
print(f"排序转换结果为:{sorted(contain5)}")


"""
排序转换结果为:['r', 's', 't']
排序转换结果为:['abc', 'str']
排序转换结果为:['efg', 'str']
排序转换结果为:['a', 'b']
排序转换结果为:[1, 2, 3]

"""

# 字符串比较大小

P51 函数

函数执行从上往下执行

def 函数名 (传入参数)：
	函数体
    return 返回值

声明函数的时候,传入参数称为：形式参数
调用函数的时候,传入参数称为：实际参数


函数返回为空 可用 return None
效果等同于不写return语句

函数说明文档

def func(x,y):
    """
    :param x: 形参x的说明
    :param y：形参y的说明
    :return: 返回值说明
    """
    函数体
    return "A"

变量的作用域

# 局部变量
# 作用于函数体内部

# 全局变量
# 在函数外部定义即为外部变量

num=20 #全局变量
def test_a():
    l= 10  # 局部变量
    num=10  # 局部变量，虽然与外部变量标识符一样，修改了num不会修改外部的num变量，如果要修改需要加上global 关键字
    global num = 10 # 会将外部num = 20 更改为num 10

# 如果在函数内部将全局变量设置为

函数多返回值


# 如果一个函数要有多个返回值

def test_return():
    return 1, 2

x, y = test_return()
print(x)
print(y)

函数多种传参方式

# 位置参数
def test(a,b):
    print(a)
    print(b)

test("a",2)

def test(a,b):
    print(f"多个相同名字函数{a+b}")

test(3,3)


# 关键字参数
def test(c,d):
    print(c)
    print(d)
test(c=5,d=6)

# 缺省参数 (默认值)
# 定义函数的时候给默认值
def user_info(name,age,sex="男"):
    print(name,age,sex)

user_info(name="小明",age=18)
user_info(name="小红",age=18 ,sex='女')


# 不定参数：补丁长参数也叫可变参数。用于不确定调用的时候会传递多少各参数

# 不定参数 -位置不定长 * 号 即位置传递

def user_info(*args):
    # args :元组
    print(args)
user_info("a",23,2432,"bb","cc")

# 不定长  --关键字不定长  ** 号  即关键字传递

def user_info(**kwargs):
    # kwargs : 字典
    print(f"我是关键字不定长：{kwargs}")

#{'name':'tome','age':18,'id':55}
user_info(name='tone',age= 18,id = 55)

# 终极函数
def user_info(*args,**kwargs):
    print(f"元组{args}")
    print(f"字典{kwargs}")

user_info('2222',432,432, age ="2" ,sex="4")

匿名函数

# 函数作为参数传递


#标记1
def test_func(compute):
    result = compute(1,2)
    print(result)

def compute(x,y):
    return x + y

test_func(compute)




"""
函数compute 作为参数，传入了 test_func 函数中使用
test_func 需要一个函数作为参数传入，这个函数需要接收两个数字进行计算，计算逻辑由这个被传入函数决定
compute 函数接收两个数字对其进行计算，compute 函数作为参数，传递给了 test_func 函数使用
最终，在test_func 函数内部，由传入的compute 函数，完成了对数字的计算

所以这是一种，计算逻辑的传递，而非数据的传递

就像上述代码那样，不仅仅是相加，相减，相除等任何逻辑都可以自定定义并作为函数传入

"""

# 标记2
def add(x,y):
    return x+y

# 标记1 的函数是数据确定(1,2)确定，但逻辑不确定
# 标记2 的函数是 逻辑确定，但数据不确定
# lambda 函数


"""
def 关键字，可以定义带有名称的函数 可重复使用
lanmbda 关键字，可以定义匿名函数（五名称） 只是用一次

匿名函数定义语法

lambda 传入参数：函数体(一行代码)

lambda 是关键字，表示定义匿名函数
传入参数表示匿名函数的形式参数 如 x,y 表示接口收两个形式参数
函数体就是函数的执行逻辑，要注意：智能写一行，无法多写代码



"""

def test_func(compute):
    result = compute(1,2)
    print(result)
test_func(lambda x,y : x+y)

print("其他模块如果调用不当，我也会输出，见py007.py")

if __name__ == '__main__':
    print("我只会在我这个文件运行的时候打印，其他文件引入我这个模块是不会运行的。见PY007.PY")

https://www.bilibili.com/video/BV1qW4y1a7fU?p=84&spm_id_from=pageDriver&vd_source=010173c6f35c758e74dd6593e5722af0

异常与包

# 异常捕获

try:
    f= open("d:/abc.txt", "r", encoding="UTF-8")
except NameError as nameError:
    # 捕获单个异常
    print(nameError)
except (EOFError,TimeoutError) as multiError:
    # 捕获多个异常
    print("multiError")
except Exception as e:
    # 捕获所有异常
    print(e)
except:
    print("捕获所有异常，不需要异常信息")
else:
    print("如果没有出现异常我就会打印，并且else 是非必要写的。")
finally:
    f.close();
    print("无论是有没有出现异常，我百分百会打印，但finally 是非必要写的")

模块

# 模块能定义函数，类和变量，
# 导入语法
# [from 模块名] import [模块 |类 | 变量|函数 |*] [as 别名]
# 常用的组合如下
"""
import 模块名
from 模块名 import 类变量方法等
from 模块名 import *
import 模块名 as 别名
from 模块名 import 功能名 as 别名
"""

# 基本语句

"""
import 模块名
import 模块名1,模块名2

模块名.功能名()  # 可以使用模块内部的全部功能(类、函数、变量)
"""
import  time
time.sleep(10)

import  time as t

t.sleep(10)

"""
from 模块名 import 功能名 as 别名 # 只导入模块中的一个功能
"""

from time import  sleep
from time import sleep as sl
sleep(1)
sl(10)

# 导入模块里面的所部功能，并且可以直接使用
from time import  *

sleep()

# 自定义一个文件就是一个模块
import py004

from py004 import test_func

## 注意事项

# 导入多个模块同名模块

# 后引入的同名模块会覆盖掉先导入的


# __main__ 变量
from py004 import test_func
# 本文件导入但是没有使用 test_func，如果运行本文件，会执行py004 里面已经写好的test_func 函数
# 只有当程序是直接执行的才会进入if 内部，如果是被导入的，则无法进入




# __all__ 变量 演示

"""
py0071 中
只显示地导出 testA 函数，没有导出test B函数

如果在py0072 中使用

from py0071 import *
则只能使用testA() 函数，不能使用testB函数

—__all__  变量 只能限制使用 *  的时候导入

如果采用
from py0071 import testB
则可以调用testB函数

"""

包

"""



从物理上看，包就是一个文件夹，在该文件夹包含了一个 —__init__.py 文件，该文件夹可用于包含多个模块文件

!!!!!    文件夹下如果有 ————init__.py 的话就是一个包，如果没有的话就是一个普通的文件夹

从逻辑上看，包的本质依然是模块

包的作用：
当我们的包文件越来越多时，包可以帮助我们管理这些模块，包的作用就是包含



"""

# 四种导入方式

from py008.py0081 import testA

from py008.py0082 import testB

from py008 import py0081
from py008 import py0082

import py008.py0081
import py008.py0082

testA()
testB()

from py008 import py0081,py0082


# 安装第三方包

"""
科学计算：numpy
数据分析： pandas
大数据： pyspark apache-flink
图形化: matplotlib 、pyecharts
人工智能： tensorflow
"""

"""
安装第三方包

cmd命令行中

pip install numpy

网速慢可用以下方法，-i 是指下载的地址，国内镜像
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple  numpy

也可以在pycharm 中中的设置 - 项目 ：python 解释器


查看安装的第三方包

pip list 


"""



def testA():
    print(22)

def testB():
    print(222)

JSON

# python 数据 和json数据相互转换

"""
转为json
json.dumps(data,ensure_ascii=False)
json转为要的数据本身可以拥有的格式
json.loads(json_str)
"""
import  json

data = [{"age":"s"},{"f":"s"}]
# true 或者不填：中文会变成asici码
json_str = json.dumps(data,ensure_ascii=False)

print(type(json_str))
print(json_str)

list_str = json.loads(json_str)

print(type(list_str))
print(list_str)



"""
<class 'str'>
[{"age": "s"}, {"f": "s"}]
<class 'list'>
[{'age': 's'}, {'f': 's'}]
"""

类 对象

类 对象 变量 方法(成员方法)

# 类定义
class Student:
    name = None
    gender = None


# 创建对象
stu1 = Student();

# 对象的属性赋值
stu1.name = 'xiaohong'
stu1.gender = 'sex'

print(stu1)  # <__main__.Student object at 0x0000018FEEFD52A0>

# 类的成员变量 类的行为，即定义在类中的函数  又称 类的成员变量
"""

## 注意区分 函数 方法 俗称
### 函数：写在类外面的方法

### 方法：写在类里面的方法


在类中定义成员方法和定义函数基本一致，但仍有细微区别

def 方法名(selft ,形参1,...形参N)
    方法体

可以看到，在方法定义的列参中，有一个self关键字

self 关键字是成员方法定义的时候 ，必须填写的。

* 它用来表示类对象自身的意思
* 当我们使用类对象调用方法的时候，self 会自动被python 传入
* 在方法内部，想要访问类的成员变量，必须使用 self

"""


class Teacher:
    name = None
    age = None

    def tech(self):
        print("我是一名老师")
        print(self.name)
        print(self.age)

    def tech(self, msg):
        print(f"你说{msg}")


te = Teacher()
# 注意调用，te.tech
te.tech
te.tech(msg="有参数")

"""
不能写同名的方法
"""

# 构造方法： __init__() 方法称为构造方法
"""
可以实现
在创建类对象的时候，会自动执行
在创建对象的时候，将传入参数自动传递给__init__方法使用

"""


class User:
    name: None
    age: None
    tel: None

# ERROR 错误写法
    # def __init__(self, name, age):
    #     self.name = name
    #     self.age = age

    def __init__(self, name, age, tel):
        self.name = name
        self.age = age
        self.tel = tel


# ERROR 错误写法
# user1 = User(name="小红", age=18)
user2 = User(name="小白",age= 18,tel= 15999999)

# print(user1)
print(user2)

"""
Traceback (most recent call last):
  File "D:\burny\gitclone\qianyi\Burny.tech\docs\system\python\code\002\py0021类.py", line 94, in <module>
    user1 = User(name="小红", age=18)
TypeError: User.__init__() missing 1 required positional argument: 'tel'
<__main__.Student object at 0x0000018A7953FFD0>

"""