1.编译和解释
编译:将写好的源代码通过编译器一次性转换为机器语言
例如 c C++ java
解释:可以直接执行源代码，执行过程中，执行到对应的代码会通过解释器转换为机器语言
例如 python JavaScript
2.java和jdk
java在编译的时候，为了满足一次编译，多处运行的特性(跨平台)
会先将源代码编译为中间语言
在第一次执行的时候,jdk会将中间语言转换为机器语言
后续执行就不需要再转换了
3.print 输出函数
print是将内容输出到屏幕(显示器)
可以输出 字符串 整数 浮点数 布尔值等内容
在输出字符串的时候，字符两边必须加引号
双引号或者单引号都可以，但是必须成对使用
示例
输出一个字符串
print('hello world')
字符串中有引号( 单引号里面有双引号)
print('hello "" world')
如果字符串中有一些特殊的符号
例如 两边都是单引号，中间有个单引号需要输出
使用转义字符
示例
print('hello \' world')
同样的情况，如果要输出\ ，也需要加上转义字符
示例
print('hello \\ world')
其他特殊的输出，这类输出可以通过转义后输出
\'
\"
\n 换行
\t 制表符,一般来说4个空格
打印的时候，可以在字符串前面加上r，让所有的转义字符不生效
示例
print(r'hello \\ world')
print(r'hello \t world')
4.print的多行输出
可以使用换行符实现字符串内容的换行输出
示例
print('1234\n5678\n9012')
可以使用三引号在输出多行的时候，保证格式正确
示例
print('''
1234
5678
abcd
''')
5.print重复输出字符串
使用*，前面的字符串重复输出多少次
示例
print('1234'*10)
6.print中输出多个字符串
拼接后输出，可以使用+ 将字符串拼接到一起
示例
print('1234'+'456'+'789')
可以使用, 分隔字符串
输出的时候会用空格来分隔输出的内容
示例
print('1234','456','789')
print('1234',456,'789') ,分隔的时候，每一个输出可以是其他的数据类型
7.print输出后会自动换行
每一个print函数在输出之后，会进行自动换行
可以在print函数输出内容的最后，加上 end='' 替换换行操作
示例
print('1234'*10,end='#')
print('1234'*10,end=' ')
也可以用空格，或者空来进行替换
8.input 输入函数
当代码执行到input的时候，程序会中断
等待用户输入内容
当用户从键盘输入内容结束后，代码会继续执行
注:单独执行input函数，从键盘输入内容后，不会记录输入的内容
一般情况下，会用一个变量来接收input输入的内容
示例
info=input()
可以在input函数的中，加入一些提示信息
示例
info=input("请输入一些内容: ")
注:input不会自动换行，如果需要换行输入内容，可以在提示内容后加入换行符
info=input("请输入一些内容: \n")
9.常量和变量
常量其实就是一个确定的数据
例如 数字 字符串 布尔值
123 'test' True
常量不可被修改,不可以被重新赋值
在定义变量的时候，会让变量名指向一块内存空间
可以对应内存当中存入一定的数据
在调用变量的，从对应的内存空间中读取对应的数据
在python中，由于python是由解释器进行内存管理
可以给变量赋予任意的数据类型
或者修改为任意的数据类型
不需要进行数据类型的约定
定义变量的格式
变量名=值
示例
info=1234
info='test'
info=True
info=[1,2,3,4]
可以给多个变量赋值
示例
info,info1=2,4
可以给多个变量赋相同的值
示例
info=info1=2
10.变量名的命名规范
1.变量名可以包含数字、字母、下划线
2.变量名的第一个字符必须是字母或下划线
3.变量名区分大小写
4.命名的变量，单词之间使用下划线 例如 user_name order_number
11.数据类型
python中一共有
整数 浮点数(小数) 字符串 布尔值 列表 元组 字典
整数 包括 正整数 0 负整数
浮点数 为小数 例如 1.0 3.14
字符串 一般需要在两边加引号 例如 '' 空字符串 ' ' 带有空格字符的字符串
'hello world' '1234'
布尔值 为 True 和 False
注:input函数，在输入内容的时候，所有数据都是以字符串的形式记录到变量中
12.数据类型的强制转换
将其他数据类型转化整型
使用int函数
print(int('1234')) 为 1234
print(int(12.34)) 为 12 直接去掉小数点的数字
print(int(12.54))
#print(int('abcd')) #不能转化呢非数字字符
print(int(True)) #True为1
print(int(False)) #False为0
将其他数据类型转化为 浮点数
使用float函数
print(float(1234)) 为 1234.0
print(float('12.345')) 为 12.345
print(float(True)) 为1.0
print(float(False)) 为 0.0
将其他数据类型转换为 字符串
使用str函数
直接转换为对应的字符串
print(str(1234))
print(str(12.345))
print(str(True))
print(str(False))
将其他数据类型转换为 布尔值
使用bool函数
对整数和小数 都是 非0为真， 0 为假
print(bool(1234))
print(bool(-10))
print(bool(0))
print(bool(12.34))
print(bool(-10.01))
print(bool(0.0))
针对字符串，只有空为假，非空为真，即使是空格也是非空
print(bool('test'))
print(bool(' '))
print(bool(''))
print(bool(None)) None在python也是空值
13.字符串的格式化输出
在字符串需要填入数据的位置，使用格式化字符进行占位
如果是字符串 使用 %s
如果是整型 使用%d
如果是浮点数 使用%f 如果是要约定小数点位数，可以 .位数f 的方式
例如 .2f 保留小数点后两位 针对数据会根据四舍五入的规则进行进位
默认填入内容是多长，就根据内容的长度来写入对应的位置
可以约定 空位的长度
例如 %10d 长度为10
如果长度超过内容，可以使用 + 右对齐 或者 - 左对齐 来设置插入的位置
示例
print("名字叫做%s,年龄为%d岁,性别为%s,身高是%.2f米,体重%d斤"%('张三',18,'男',1.756,130))
约定某个内容显示的长度
print("名字叫做%s,年龄为%-10d岁,性别为%2s,身高是%.2f米,体重%d斤"%('张三',18,'男',1.756,130))
注：格式化输出的时候,输入的内容需要和占位符一一对应
14.使用字符串的format函数进行格式化输出
使用format函数
在字符串中，填入{}进行占位，如果{}的内容为空，和后面填入的内容一一对应
但是可以使用后面内容的编号
{0} 使用第一次参数
{1} 使用第二个参数
示例
print("名字叫做{0},年龄为{1}岁,性别为{0},身高是{0}米,体重{0}斤".format('张三',18))
如果要重复的调用某些数据来填入，这种方式会更方便
15.运算符
常见的 + - * /
** 指数 例如 10**3 10的三次方
% 取模 即取余数 例如 10%3 余数为1
// 地板除 即最大的倍数 例如 10//3 为3
16.赋值运算符
= 赋值运算符
将右边的值赋给左边的变量
赋值运算符，可以和运算符相结合
a=100
a+=200 这种方式为 a=a+200
这种方式为 这个变量与后面的值进行运算的结果
a=100
b=50
a-=b 为 a=a-b
将运算的结果赋给这个变量
其他的也是这样
*= /= %= **= //=
17.比较运算符
比较两边的值，如果符合比较的条件，那么返回 True
如果不符合比较的条件 那么返回 False
== 等值比较 可以比较 整数 小数 字符串 布尔值
!= 不等值比较 当不相等 返回 True 相等的时候 返回False
> 对数字进行比较，左边大于右边返回True 否则返回 False
如果针对字符串，会依次比较字符串中 字符在字符集的位置
靠后的更大
示例
a='c'
b='b'
print(a>b)
< 和>符号相反
>= 大于等于
<= 小于等于
18.逻辑运算符
and 两边都为真的时候，返回True
当两边任一一边为假的时候，返回False
注:逻辑运算符两边可以是其他数据类型，根据其他数据类型的转换
判断为真或者假
None 不可以用来做判断
or 两边任一一边为真的时候，返回True
只有两边都为假的时候，返回False
not 真返回假 ，假返回真
注：逻辑运算符的优先级 满足
not and or
19.运算符的优先级原则
1.幂 指数
2.乘除
3.加减
4.比较
5.赋值
6.逻辑
条件判断和循环
1.程序代码的结构
代码一般情况下会按照从上到下的顺序依次执行
是一种顺序结构，是线性并且有序的
但是在有些情况下，需要根据逻辑判断选择一些代码来执行
跳过不符合判断条件的代码
这种结构称为选择结构
还有就是在满足条件的情况下，会循环的执行某一段代码
在不满足条件之后，会结束执行
继续执行后续的代码
这种结构称为循环结构
2.选择结构 if else
语法结构
if 判断条件:
需要执行的代码
示例
age=int(input("请输入的年龄 "))
if age<70 and age>14:
print("你需要买门票")
else需要和if成对使用:
当if语言判断的结果为假的时候执行
else：
需要执行的代码
注:else一定和if成对使用
如果有多个if，有一个else
else一定是对应最近的if语句
3.elif语句
在if语句判断为假的时候，可以再进行一次判断
当if语句判断为真的时候，后续的代码不会被执行
elif 判断条件:
代码
示例
if age<60 and age>18:
print("你需要买全票")
elif age>14 and age<70:
print('你需要买半票')
else:
print('不需要买门票')
3.while 循环
当while的判断条件为真的时候，会循环的执行循环体里面的代码
指导循环的判断条件为假才结束(跳出循环)
while 判断条件:
循环体
一般情况下，在循环体中，需要设置循环结束的条件
不然循环会变成死循环(会一直执行，不会结束，除非强行终止)
示例
num=0
while num<10:
print(num,end=' ')
num+=1 #循环结束的条件
mark=True
while mark: #如果mark一直为True,循环会一直执行
print('死循环')
可以让while循环和if判断语句结合
当达到某个条件时，让循环结束
示例
mark=True
while mark:
info=input("输入end结束: ")
if info=='end':
mark=False
else:
print('死循环')
循环当中可以嵌套循环
当外层的循环执行一次的时候，内层要将整个循环执行结束
示例
a=0
while a<10: #当a为任一一个数的时候，会执行内层的循环
b = 0
while b<10: #会将b从0到9全部打印一遍
print(b,end=" ")
b+=1
print("%d分段"%a)
a+=1
4.for循环
for循环的循环次数是根据后面数据序列中，数据的个数
有多少个会循环多少次
格式
for 变量 in 序列:
循环体
每循环一次，会将序列当中的一个数读取出来赋给前面的变量
并且让循环体执行一次
示例
for i in (10,20,30):
print(i)
如果不想使用这个变量
也可以将 变量设置为 _
循环执行的次数不变
for _ in (10,20,30):
print('test')
在python中，可以使用 range 自动的生成一个序列
一般填写2个参数，从第一个参数开始，每循环一次+1
即将等于第二个参数时，序列结束
range(1,10) 生成一个 1到9的序列
示例
for i in range(1,10):
print(i,end=' ')
如果设置1个参数，生成一个从0开始序列
示例
for i in range(10):
print(i,end=' ')
还可以设置第3个参数，第3个参数为步长
默认情况下每次+1，设置第3个参数，那么每次 + 步长
序列的当中的数据，即将等于第二个参数的值或者大于第二个参数的时候
序列结束
示例
for i in range(1,10,3):
print(i,end=' ')
可以设置步长为负数
就需要正确设置 range的前两个参数
保证生成一个正确的反向序列
示例
for i in range(10,-10,-2):
print(i,end=' ')
5.for循环可以用于处理一些序列
例如 字符串
for i in 字符串:
会依次将字符串中的每一个字符读取出来
注：只要后面是一个序列，就可以依次读取出序列中的每一个元素
示例
for i in "hello world":
print(i,end=" ")
6.break
当循环执行到break的时候，整个循环终止
跳出循环
break对 while和for循环都生效
示例
for i in range(1,10):
if i==6:
break
print(i)
i=0
while i<10:
if i==6:
break
print(i)
i+=1
注:break一般和if判断条件结合使用
当等于某个条件的时候，循环结束
7.continue
continue 当循环执行到continue的时候
结束本次循环，执行跳入下一次循环
示例
for i in range(1,10):
if i==6:
continue
print(i)
for循环在执行continue的时候
应该for循环的执行次数，在生成序列的时候已经确定
i=0
while i<10:
i+=1
if i==6:
continue
print(i)
在执行while循环的时候
在注意把循环结束的条件写在continue的前面
避免产生死循环
以下是死循环的代码
i=0
while i<10:
if i==6:
continue
print(i)
i+=1 当i为6时,循环结束的条件永远不会被执行
函数
1.函数可以理解为是一段可以重复使用的代码
在定义的时候，可以给函数命名一个名字 -- 定义
同时设计函数需要输入并进行处理的数据 -- 参数
获取函数运行结束之后会返回哪些数据 -- 返回值
通过函数名来调用函数 -- 调用
注:参数在函数定义时称为 形参
参数在函数调用时称为 实参
2.函数定义的格式
def 函数名(形参列表):
函数体
返回值
注:形参列表和返回值可以为空
示例
def test1(): -- 函数的定义
print("测试打印文本")
test1() -- 通过函数名来调用，主要加上括号
def test2(a,b): --定义函数时，定义了形参
print(a+b) --形参没有具体的值，告知解释器，该函数该怎么执行
test2(10,20) --在调用时，再传入具体的值进行运算
3.返回值
返回值的作用是将函数运行的结果返回出去
可以用一个变量接收函数返回的值
当函数在运行过程中，如果遇到返回值，函数将执行结束
示例
def add_num(a,b):
return a+b
print(add_num(10,20)) -- 直接打印输出函数的返回值
num=add_num(100,200)
print(num) --可以用变量接收函数的返回值，然后再打印
def add_num(a,b):
return a+b
return a*b -- 该行语句不会被执行
在一个函数中，可以有多个return
一般会结合一些逻辑处理，根据不同的逻辑处理结果来返回
示例
def ticket(age):
if age>=70 or age<=14:
return 'free'
elif age>=60 or age<=18:
return 'half'
else:
return "total"
可以用return返回多个值
def test_result(a,b,c):
return c,b,a -- 可以用return返回多个值
print(test_result(10,20,30)) -- 直接打印，以元组的形式返回值
num=test_result(10,20,30) --可以用一个变量来接收，这个变量的值是一个元组
print(num)
num1,num2,num3=test_result(10,20,30) --如果要用多个变量来接收
那么有多个返回的值，就需要用多少变量来接收
print(num1,num2,num3)
4.局部变量和全局变量
函数中定义的变量是只能存在函数中
即使是同名的变量，也不会对外部的值造成影响
因为函数中的变量都是局部变量
示例
a=100 生成一个外部的变量
def change_num():
a=500 生成一个函数的局部变量
print(a) 打印外部的变量的值
change_num() 调用函数，生成局部变量的值，调用结束之后，这个变量会被销毁
print(a) 再次外部变量的值
注:一般情况下都是用return 将函数运行的结果返回出来
可以使用global定义函数内部的变量为全局变量
注:全局变量一定是先定义 再赋值
示例
a=100
def change_num():
global a --定义全局变量
a=500
print(a)
change_num() --全局变量在函数调用的时候会修改变量的值
print(a)
5.默认参数
函数在定义时，定义了多少个形参
在调用时，就需要传入对应个数的实参
在函数定义时，可以给形参设定一个默认值
在调用函数的时候，该形参对应的值可以不传入，默认使用这个默认值
注:默认参数从参数列表的末尾开始定义
示例
def calc(a,b,c='+'): --定义第三个参数是默认参数
if c=='+':
return a+b
elif c=='-':
return a-b
print(calc(10,20)) --使用默认参数，第三个参数可以不传入
print(calc(10,20,'-')) --第三个参数传入了值，默认参数不生效，使用传入的值
6.关键参数
函数在调用时，形参和实参必须一一对应
关键参数是在 函数调用的时候，可以使用 形参=实参 的方式来传入参数
可以修改参数传入的顺序
示例
def calc(a,b,c):
if c=='+':
return a+b
elif c=='-':
return a-b
print(calc(c='-',a=100,b=20)) --修改实参列表的传入顺序
7.函数的递归调用
在定义函数时，可以在函数体中 调用函数自己本身
但是注意设置函数调用的结束条件，保证函数的所有调用可以正确的结束
示例
def peach_num(days):
if days==1:
return 1 -- 函数结束调用的条件
else:
return (peach_num(days-1)+1)*2 -- 要注意days-1，保证可以达到这个条件
print(peach_num(5))
注：递归调用的好处在于执行效率比较高
但是在调用时，会占用大量的内存
模块
1.模块
python中有很多函数，可以直接使用，这些是python解释器中内置的函数
例如 len print round abs
但是有些函数，需要手动的去引入对应的模块才能够调用
模块分为3种类型
1.python自带的模块
一般存在放在python解释器安装路径的 \Lib 文件夹下
2.第三方模块
一般存在放在python解释器安装路径的\Lib\site-packages文件夹下
第三方一般需要安装
使用 pip 或者 pip3这个命令来进行安装
注:需要在环境变量中加入 \Scripts\ 文件夹的路径
使用 pip list 查看已经安装的包名
pip install 包名 安装对应的包
pip uninstall 包名 删除对应的包
这个命令使用pip3也可以
3.自定义模块
一般存在当前项目的工程文件中
可以通过导入这个文件，来使用这个文件中的函数
注：自定义的模块尽量不要和第三方模块甚至自带的模块重名
如果出现同名，模块调用的顺序是先本地再模块的库
2.模块的调用方法
1.from 模块名 import 函数名
注:可以理解为模块名就是 python的文件名
示例
from random import randint
2.from 模块名 import 函数1,函数2 ....
可以使用这种方法，调用多个函数
示例
from random import randint,choice
3.from 模块名 import *
可以调用这个模块下的所有函数
示例
from random import *
注:如果在调用模块时，调用了多个模块
但是模块中有函数的名字相同，可以给函数设置别名
但是在函数被使用的时候，必须使用别名
from random import randint as r1,choice as r2
a=[1,2,3,4,5,6,7,8]
print(r2(a))
print(r1(1,100))
4.使用 import 模块名
注意在使用时，需要使用 模块名.函数名的方法来调用
示例
import random
a=[1,2,3,4,5,6,7,8]
print(random.choice(a))
print(random.randint(1,50))
注：如果在调用自定义模块时，在pycharm这个工具中
如果模块在某个文件夹下，需要使用
文件夹.模块名
例如 from lianxi.lianxi3 import peach_num
lianxi是一个文件夹
列表元组字典
1.列表 元组 字典
这三个数据类型都是python自带的数据类型
列表和元组是有序的，可以使用索引或者下标来访问
字典是无序的
2.列表
列表是由一组数据组成，数据可以由任意数据类型构成
列表的定义
列表名=[元素1,元素2....元素n]
示例
list1=[1,2,3] -- 定义一个都多个元素的列表
list2=[1] -- 定义只有一个元素的列表
list3=[] -- 定义了一个空列表
list4=['abc',5,True,3.14] -- 列表当中的元素可以是任意数据类型
list5=[list1,list2,False] -- 列表当中的元素可以是其他列表
列表的访问
print(列表的名)
示例
print(list1)
列表当中元素的访问
使用 索引值(下标)的方式访问列表中的元素
列表名[索引值]
示例
print(list1[0]) --访问第一个元素，注意索引值从0开始
print(list1[1]) --访问第二个
print(list1[2]) --访问第三个
#print(list1[3]) -- 该列表只有3个元素，索引值最大为2，超过索引值进行访问会产生越界错误
print(list1[-1]) -- 可以用负值从末尾开始访问，-1访问最后一个元素
print(list1[-2]) --倒数第二个
print(list1[-3]) --倒数第三个
#print(list1[-4]) --总共3个，同样产生越界错误
可以使用len来，获取列表的长度，来访问列表中元素
print(list1[len(list1)-1])
注:获取长度之后，要访问最后一个，需要用长度-1
更新列表中元素的值
列表名[下标]=新值
示例
list1[0]=999
print(list1)
3.列表的常用函数
list1.append('5') -- 在列表末尾添加一个元素
list1.clear() --删除列表当中的所有元素(把列表清空)
list1.insert(1,'xyz') --在某个索引值的位置插入一个元素，从该索引值开始后面所有的元素向后+1
list1.pop() --默认删除最后一个元素
list1.pop(2) -- 可以加上索引值，删除对应索引值的元素
list1.remove('x') -- remove是删除列表当中某一个元素(必须使用元素的值来进行删除)
例如可以使用 if 'x' in list1：
list11.remove('x')
list1.count(999) -- 计算列表中,某个值在列表当中出现的次数，有多少个对应的值，就会显示多少个
例如可以结合 remove 删除列表当中对应值的所有元素
while list1.count(999):
list1.remove(999)
list1.index(999) -- 显示这个值，在列表当中第一次出现的索引值
list2=list1.copy() -- 将list1复制给list2
list6.sort() -- 对所有元素进行排序，注意，必须保证所有的元素的数据类型一致
例如 所有的数据是数字 或者 字符串
sort默认是升序
list6.sort(reverse=True) -- 可以加上参数reverse=True 将其设置为降序
list1.reverse() --将列表进行反转 (倒序排列)
注：上述的函数中，除了index 和count以外
其他的函数都会对列表进行修改
4.列表的切片访问
可以通过索引来查看列表中某一段内容
列表名[开始索引:结束索引:步长]
从开始索引开始，到结束索引之前1个结束(不能超过或者等于结束索引)
步长默认为1，可以设置间隔的值
示例
print(list1[1:3]) --取第二个元素到第三个元素
print(list1[1:6]) --列表长度为7，索引最大值为6，结束索引不取，只能取到倒数第二个元素
print(list1[1:]) --如果要将后面的元素取完，不写出结束索引
print(list1[:4]) --要从头开始访问，可以将开始标签写为空
print(list1[-6:-1]) -- 可以使用负数来做为索引
注:默认步长为1，所以访问顺序一定是前到后
索引值一定是从小到大
print(list1[1:6:2]) -- 步长可以理解为 索引增加的值
注:如果要设置从后到前访问，可以将步长设置为负数
print(list1[6:1:-1]) -- 设置步长为负数，从后面的索引开始访问
print(list1[::-1]) -- 如果不设置开始和结束索引，会将列表反转
注:索引的切片访问都不会对列表产生修改
6.元组的定义
元组也是保存一组数据
和列表一样，可以保存任意数据
格式
元组名=(元素1,元素2...元素n)
示例
tuple1=(1,2,3,4) -- 定义多个元素的元组
tuple2=(1,2,3,'abc') --元组的元素可以是任意的数据类型
tuple3=() --定义一个空元组
tuple4=('abcd',) --如果元组只有1个元素，需要在元素的结尾加上一个,
7.元组的访问
元组和列表一样，是一个有序的数据类型
所以可以使用 索引或者切片的方式来访问
示例
print(tuple1[0]) -- 通过索引访问元组中的值
print(tuple1[3])
print(tuple1[1:5]) -- 通过切片访问元组中的值
8.元组的常用函数
元组和列表不同的地方在于，元组不可以被修改
print(tuple1.index(2)) -- 通过index查找元组中元素的索引值
print(tuple1.count('x')) -- 通过值来查找元组中元素的出现的次数
#tuple1[2]=10 -- 元组中的值不可以被修改，会报错
#del tuple1[0] -- 也不可以删除元组中的元素
9.元组和列表的遍历和转换
可以使用for循环遍历元组和列表中的所有元素
示例
for i in list4:
print(i)
for i in tuple1:
print(i)
还可以通过索引来遍历
for i in range(0,len(list4)): #因为range的最后一个值不取，符合索引的要求，不会引发越界错误
print(i,list4[i])
可以使用list 和 tuple将列表和元组相互转换
示例
print(list(tuple1))
print(tuple(list4))
10.字典
字典是由一组数据组成，每个元素由键和值构成
字典是一个无序的数据组合，不能通过索引访问
每个字典中，键是不能重复的，值可以重复，值可以是任意数据类型
格式
字典名={键1:值1,键2:值2....键n:值n}
示例
dict1={1:'a',2:'b',3:'c','x':'abcd'} -- 定义一个字典
dict1={1:'a',2:'b',3:'c','x':'abcd',1:'xyz'} -- 在定义时，字典中的键可以重复
但是后面的值会覆盖前面的值
dict2={} --定义一个空字典
11.字典的访问
字典是通过键来访问对应的值
示例
print(dict1['x']) --通过键的名字来访问键对应的值
可以使用for循环遍历字典中的所有元素
for循环是读取字典中所有的键，然后可以通过键来输出对应的值
示例
for i in dict1:
print(i,dict1[i]) --先打印出对应的键，然后再通过键访问对应的值
12.字典的函数和字典修改
修改字典中键对应的值
dict1['x']='123456789' --要保证这个键存在
如果这个键不存在，会添加这个元素(对应的键和值)
dict1['y']='test' --可以通过不存在的键和对应的值 ，来将这个键值对添加到字典当中
dict2=dict1.copy() -- 复制字典
dict2.clear() -- 清空字典
print(dict1.keys()) --打印出字典中所有的键
print(dict1.values()) --打印出字典中所有的值
print(dict1.get('x')) --获取字典中这个键对应的值
dict1.pop('x') --删除这个键，因为字典中元素是由 键值对构成的
一旦删除这个键，对应的元素就被全部删除
13.字段串也是一个序列
字符串也可以通过下标来访问，也可以切片访问
str1='abcdefghijklmn'
print(str1[2]) --通过下标来访问字符串中某个字符
print(str1[1:5]) --通过切片来访问字符串中部分字符
print(str1[::-1]) --可以将字符串反转
注:字符串可以元组类似，不可以通过下标去修改字符串中的字符内容
14.字符串和列表的转换
split将字符串转换为列表
示例
str1="learning python\n"
list1=str1.split() -- 如果不加参数，在转换的时候，会默认去掉换行符
-- 查找字符串中空格，将 字符串分割为列表中元素
print(list1)
list2=str1.split(" ") -- 如果使用参数" ",就不会去掉换行符
print(list2)
str2="learningpython"
list3=str2.split("gp") --可以使用字符串中任意字符来进行分割，对应的字符会被去掉
--把其他的内容分割为不同的元素
--如果在字符串中找不到对应的内容，就将字符串处理为一个元素
print(list3)
join将列表转换为字符串
示例
list1=['a','b','c','d']
str1=" ".join(list1) --使用空格将列表当中的元素拼接为一个字符串
print(str1)
list1=['a','b','c','d']
str1="x".join(list1) --可以使用任意字符串将列表中的元素拼接为一个字符串
print(str1)
str1=" ".join(list1)+'\n' -- 如果想在拼接后的字符串中加上换行符，使用+ 拼接一个换行符即可
文件读写
1.对文件的读写
open : 打开对文件的读写通道
在打开文件的时候，需要设置对文件的读写方式
r : 只读，只能使用读的函数
文件指针指向文件内容的开头
r+： 可读可写,文件指针指向内容开头
w : 可写, 只能使用写的函数
如果文件由内容，会覆盖原有的内容，如果没有，会新建一个文件
w+ ：可读可写 ，方式和w 一样
a : 可写, 只能使用写的函数
文件指针指向文件内容的末尾，将要写的内容填充到末尾
如果文件不存在，会新建一个文件
a+ : 可读可写，方式和a 一样
格式
文件的对象=open(文件的路径和文件名,文件的读写方法)
示例
file1=open('d:\\lianxi\\1.txt','r') -- 要注意路径的转义字符,需要使用 \\
file1.close()
file2=open(r'd:\lianxi\1.txt','r') -- 也可以使用 r 让转义字符失效
file2.close()
2.读的方法
read -- 读取出文件的所有内容
将读取出的内容返回
示例
info=file1.read()
print(info)
readline -- 读取出文件中一行内容，文件指针会指向下一行的开头
示例
info=file1.readline()
print(info)
info=file1.readline()
print(info)
readlines --读取出文件中的所有内容，但是把每一行内容做为一个元素写入一个列表中
示例
info=file1.readlines()
print(info)
seek函数，修改文件指针的位置
seek 的第一个参数，是文件内容偏移量
第二个参数是，是指针的位置 0 文件内容开头
1 当前位置
2 文件内容末尾
seek(0,0) -- 指向文件内容开头位置
3.写的方法
write --将内容写入文件，并覆盖原有内容
示例
file1.write("test") -- 将字符串的内容写入文件
writelines -- 将一组数据，依次写入文件中
如果要想要换行，就内容末尾需要手动加上 换行符
示例
list1=['1234','5678','xyzf'] -- 这种方式不会换行，会将所有内容写为一行
file1.writelines(list1)
list1=['1234\n','5678\n','xyzf\n'] --这种方式可以手动换行
file1.writelines(list1)
使用a的方式添加内容
示例
file1=open('d:\\lianxi\\1.txt','a') --将文件操作类型变为 a
list1=['1234\n','5678\n','xyzf\n']
file1.writelines(list1) -- 仍然使用文件 写的方法 ，就将内容写入到文件末尾
file1.close()
4.文件读写的其他格式
使用
with open() as 文件对象:
文件内容操作的代码
示例
with open('d:\\lianxi\\1.txt','a') as file1:
list1 = ['1234\n', '5678\n', 'xyzf\n']
file1.writelines(list1)
注：这种方式不需要再手动写close函数，会在文件内容操作结束之后，自动的调用close方法关闭文件读写
with open('d:\\lianxi\\1.txt','r') as file1:
info=file1.read()
print(info)
异常处理
异常处理
1.当程序代码有错误，执行到这一行代码的时候会引发这个错误
到这程序执行终止，这种情况称为异常
异常处理指得是，当程序发生异常的时候
对异常处理进行捕获，用一些代码来替代异常发生的情况
让程序代码可以继续执行
2.格式
try:
可能异常的代码
except：
处理异常的代码
注：没有发生异常的时候，except里面的代码不执行
只有当发生异常的时候，except中的代码才会继续执行
示例
def num_add(a,b):
return a+b
a=10
b='c'
try:
print(num_add(a,b))
except:
print("数据类型错误")
print(a,b)
3.异常的类型
except可以捕获任意类型的异常
如果想要捕获特定的异常类型
可以使用
except 类型: 的格式来捕获特定的异常
示例
try:
print(num_add(a,b))
except ZeroDivisionError:
print("输出不能为0")
注:这种方式只能捕获特定的异常，如果有多种异常情况
可以用多个except 异常类型
示例
try:
print(num_add(a,b))
except ZeroDivisionError:
print("输出不能为0")
except TypeError:
print("数据类型错误")
如果多个异常类型想使用相同的处理方式
可以使用()将多个异常类型合并一个组
示例
try:
print(num_add(a,b))
except (ZeroDivisionError,TypeError):
pass
如果发生的异常可能会比较多，那么除了指定特定的异常情况外
还可以在后面写一个except，捕获其他未知的异常
示例
try:
print(num_add(a,b))
except (ZeroDivisionError,TypeError):
pass
except: #上面两种异常会被另外处理，发生了这两种异常之外的，执行except后面的代码
print("发生了异常")
4.else
当异常处理中，没有捕获到异常的时候，可以使用else
去执行对应的代码
示例
try:
print(num_add(a,b))
except (ZeroDivisionError,TypeError):
pass
except:
print("发生了异常")
else:
print("没有异常")
5.finally
不管是否发生了异常，都会执行对应的代码
示例
try:
print(num_add(a,b))
except (ZeroDivisionError,TypeError):
pass
except:
print("发生了异常")
else:
print("没有异常")
finally:
print("继续执行")
面向对象的基础
1.类和对象
类是一种事物的抽象
需要把事物的属性和行为抽象出来
对象是这种抽象的实例
类里面定义的函数称为 方法
类里面定义的变量称为类变量，实例变量称为实例变量
2.类的定义
class 类名:
定义类的代码
初始化方法
def __init__(形参列表):
该方法的格式必须是 前后两个_ 中间是init
该方法会自动的在生成实例的时候进行调用
类的方法中，形参第一个一定是 self
该参数是指向实例本身
变量如果没有使用 self.变量名 该变量是不是被其他方法调用的
示例
class pencil:
def __init__(self,color): --初始化方法
self.color=color
def write(self):
print("写的是%s颜色的字"%self.color)
如果不希望变量在外部被修改
只能通过方法来修改，可以将变量定义为 私有变量
示例
def __init__(self,color): --将变量定义为私有
self.__color=color
def change_color(self,new_color): -- 通过实例无法修改变量的值，可以通过方法来修改
self.__color=new_color
3.继承
定义一个子类
class 类名(父类名):
子类可以继承父类的变量和方法，不能继承私有的
示例
class draw_pencil(pencil):
def draw(self):
print("画了一幅%s颜色的画"%self.color)
子类可以定义和父类相同名字的方法
这种方法会产生 重写
示例
class pencil:
def __init__(self,color):
self.color=color
def write(self):
print("写的是%s颜色的字"%self.color)
def change_color(self,new_color):
self.color=new_color
class draw_pencil(pencil):
def draw(self):
print("画了一幅%s颜色的画"%self.color)
def write(self): --定义了和父类同名的方法
print("写的字非常的粗")
注:一个父类可以有多个子类
网络编程的基础
1.urllib
在python3中，只有urllib库
会使用 request 模块
示例
from urllib import request
def report(a,b,c):
per=100.0*a*b/c
if per>100:
per=100
print("%.2f%%"%per)
request.urlretrieve("https://www.python.org/ftp/python/3.10.0/python-3.10.0-embed-amd64.zip",\r'd:\lianxi\python.zip',report)
可以通过urlretrieve下载网络中的文件
第一个参数是 url地址
第二个参数是 当前路径保存的地址
第三个参数是 回调函数，可以显示下载进度
request.urlretrieve("https://www.163.com/",\
r'd:\lianxi\163.html',report)
也可以用于下载网页文件，注意网页文件没有大小，不能正常显示进度
2.使用urlopen去读取接口的数据
info=request.urlopen("http://www.kuaidi100.com/query?type=yuantong&postid=801515468636327825")
使用urlopen访问http协议的接口
str1=info.read()
通过read方法读取接口返回的数据
print(str1.decode())
对接口返回的数据进行重新编码
3.json格式
网络返回的数据往往是json格式
可以通过json这个方法对数据进行处理并读取数据中的内容
示例
new_info=json.loads(str1.decode()) -- 通过json对数据进行格式化处理
print(new_info["message"]) --根据数据格式的特点来输出对应的内容
print(new_info['data'][0]['time']) -- 如果要输出下面几层的数据，可以结合字典和列表的特点来输出
例如 列表使用下标 字典使用 key来访问
数据库操作基础
1.pymyql
要连接不同的数据库系统需要导入对应的模块
要连接mysql数据库可以使用 pymysql
由于pymysql是第三方模块
需要使用 pip3 install pymyql进行安装
2.pymysql的常见函数
connect函数，连接数据库，返回数据库的连接对象
重要参数
conn=pymysql.connect(host="127.0.0.1",user='root',passwd='123456',\
port=3306,db='lianxi',charset='utf8')
host 数据库服务器所在主机名或者ip地址
user 数据库服务器的用户名
passwd 数据库服务器的密码
port 默认端口3306,可以填入自定义端口
db db的名字
charset 由于数据库系统往往使用 utf8 而如果使用 windows系统，系统往往使用的是GB码
中文可能会显示为乱码，需要指定代码运行过程中使用的编码格式
close函数，关闭数据库连接
数据库连接数是有限的，所以在执行完sql操作之后，需要释放对应的连接
cursor函数，游标函数
游标会指向我们将要获取的数据
例如 使用sql获取了10条数据，需要用游标去指向对应的数据
才能知道获取了哪些，还剩下哪些
可以使用游标对象去执行sql语句
使用fetchXXX方法获取sql执行后的数据结果
fetchall -- 获取sql查询出来的所有数据
fetchmany -- 可以指定获取几条数据
fetchone -- 获取一条数据
示例
cur.execute("select * from emp where deptno=1001;") --执行sql语句
print(cur.fetchmany(3))
print(cur.fetchone())
execute: 执行sql语句
示例
cur.execute("select * from emp where deptno=1001;")
executemany: 该函数可以一次性执行多个sql语句,该方法不能用于查询
3.通过python执行增删改的操作
可以通过execute执行sql语句
但是增删改会对数据进行修改，所以修改之后，需要使用 commit方法来进行提交
示例
cur=conn.cursor()
num=cur.execute("update emp set sal=7000 where empno=10000006;")
print(num)
conn.commit() -- 当对数据做了修改之后，使用commit进行提交
当在修改过程中，发生了异常，可以使用rollback对已经做的修改进行回滚
注:commit和rollback都需要是使用 数据库的连接对象来操作
4.sql的参数化执行
可以将sql当中数据参数化，例如where条件中的数据
在sql当中使用 %s 进行占位，然后用对应数据或者变量传入对应的值
示例
cur.execute("select * from emp where deptno=%s;",deptno)
如果有两个或者多个需要传入的值，使用括号，将需要传入的值进行合并
示例
num=cur.execute("select * from emp where deptno=%s and sal>%s;",(deptno,sal))
通过参数传入来进行增删改的操作
示例
num=cur.execute("insert into test value(%s,%s,%s);",(id,name,sal))
print(num)
可以使用executemany 一次性执行多条数据的修改
list2=((1,'lisi',100),(2,'zhangsan',200),(3,'wangwu',300))
num=cur.executemany("insert into test value(%s,%s,%s);",list2)
注:这种方法实际上是使用sql和后面的参数进行组装
组装为多个sql来执行，实现多个数据一次性修改
正则表达式
1.正则表达式
是一段规则字符串，常使用这个规则字符串对文本内容进行检索
检索出符合规则字符串的内容
2.re模块
需要导入re模块来引入正则表达式
使用findall 来找出满足规则的字符串
re.findall(规则字符串,被搜索的文本)
示例
m=re.findall("[Hh]i",txt)
如果有检索到内容，会将匹配的内容赋值给m
如果没有则为空
3.元字符
如果不使用元字符，会在搜索内容中精确搜索，只有被完全匹配的才会被检索出
. 可以匹配任意一个字符
\ 转义字符，让规则字符不生效
[] 字符集。这个字符可以是这个字符集中任意一个
如果是英文的字符 A-Z 代表A到Z中的任意一个字符 也可以取一段 A-H
A-Ha-h 这样也是可以的 代表 A到H 或 a-h
\d = [0-9] 任意数字字符
\D = 任意非数字字符 等同于[^\d]
^字符取反,对后面的字符集取反
\s 任意空白字符 --包括 空格 换行符 制表符等
\S 非空白字符
\w 单词字符 包括 [A-Za-z0-9_]
注意包括下划线
\W 非单词字符
-- 以上的内容可以匹配对应的1个字符
* 前一个字符出现0到无限次，应用贪婪模式
贪婪模式指的是 只要下一个字符符合匹配条件就继续检索,直到不符合条件
+ 前一个字符出现1次到无限次，应用贪婪模式
? 前一个字符出现0次或1次
{m} 两边使用大概括，次数，前一个字符出现m次
{m,n} 前一个字符出现m到n次，应用贪婪模式 例如 {2,4}
*? +? {m,n}? 可以构成非贪婪模式，非贪婪模式以最小的数量进行匹配
-- 以上内容为数量次，控制匹配字符的出现次数
^ 只匹配开头的位置 ^\d+
$ 只匹配结尾的位置 \d+$
\b 如果是要匹配中间内容的边界,可以设置左或右边界
例如 r"\d+_\b" 左边界为_
\B 某些内容不是边界
-- 以上是对边界进行检查
| 如果有多个规则字符串，可以使用 | 进行分隔
可以使用多个规则字符进行匹配 示例 abc\d+|def\d+
() 可以将规则字符串做为分组来处理，再加上数量次进行匹配 示例 (abc){2}
1264
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
