python:动态类型,强类型的语言
Python是一种计算机程序设计语言。是一种动态的、面向对象的脚本语言,最初被设计用于编写自动化脚本(shell),随着版本的不断更新和语言新功能的添加,越来越多被用于独立的、大型项目的开发。
内建函数:
格式化输出:(print())
print("英语成绩为:%f,数学成绩为:%f"%(69.5,69.5)) %f %d %s占位符,分别代表浮点数、整数、字符串
print(123,end = " ") end参数,默认为换行,加空格为空格隔开
print(123,end = "\n") 默认
输入:(input())
不管输入的什么类型,默认转化为字符串
查看类型:(type())
print(type(name)) 查看name的数据类型
返回内存中的地址:(id())
num = 123
print(id(num)) 查看num在内存中的地址
转换为整型:(int())
转换为浮点型:(float())
变量:
命名规则:
- 不需要声明,可直接赋值
- 变量可以存储不同的数据类型
- 可以同时为多个变量赋值
- 变量命名是可以由数字字母下划线组成,不能以数字开头,区分大小写,不能使用$符命名
- 不支持自增自减
- 变量名不可以是关键字和保留字
数据类型:
-
数值型
- 整数(int)没有小数点的数,大小取决于电脑内存的大小,没有上限
- 浮点数(float)只要有小数点的就是浮点数,无穷小数会做精确处理
- 复数(complex)虚部以j或者J结尾的数为复数
- 浮点数和整数的转换:float() int()
- 将十进制转换为二进制、八进制、十六进制:bin()、oct()、hex()
-
字符串:
-
单引号
-
双引号
-
三引号
-
转义字符""
- 前缀:r 代表后面的字符串是一个普通的字符串;
- b 代表后面的字符串是byte数据,在python2中print函数操作的字符串全部为byte型数据,在python3中操作的是Unicode数据;
- u 主要是python2为了兼容python3
-
切片:
str = "今天是周五" print(str[start:end:step])
-
字符串中的内建函数:
-
String.capitalize()
首字母大写 -
String.lower()
全部小写 -
String.upper()
全部大写 -
String.center(len,"*")
扩充成长度为len的字符串,以原来字符串为中心在两边以*扩充 -
String.ljust(len,"*")
扩充成长度为len的字符串,以原来字符串为中心在右边以*扩充 -
String.rjust(len,"*")
扩充成长度为len的字符串,以原来字符串为中心在左边以*扩充 -
String.count("str",start,end)
原字符串中从开始到结束str出现的次数(start和end可省略) -
String.encode(encoding = "utf-8",errors = "ignore")
以指定格式编码,无法编码的字符自动忽略 -
String.decode(encoding = "utf-8",errors = "ignore")
以指定格式解码,无法解码的字符自动忽略 -
String.endswith("0")
是否以0结尾,返回一个布尔值 -
String.find("str",start,end)
返回str的位置下标,没有就返回-1(从左往右) -
String.rfind("str",start,end)
返回str的位置下标,没有就返回-1(从右往左) -
String.index("str",start,end)
返回str的位置下标,没有就报异常(从左往右) -
String.rindex("str",start,end)
返回str的位置下标,没有就报异常(从右往左) -
String.isalnum()
至少有一个字符,并且所有字符都为字母数字,返回一个布尔值 -
String.isalpha()
至少有一个字符,并且所有字符都为字母,返回一个布尔值 -
String.isdigit()
至少有一个字符,并且所有字符都为数字,返回一个布尔值 -
String.islower()
是否全部都为小写,返回一个布尔值 -
String.isupper()
是否全部都为大写,返回一个布尔值 -
String.isspace()
至少为一个字符,并且字符串是否全为空,返回一个布尔值 -
String.join()
将列表对象用string进行分割组合为字符串arr = ["1","2","3","5"] print(",".join(arr))
-
String.split("str",num)
将字符串用str进行分割转换为列表,可指定列表长度为num -
String.splitlines()
将string通过\n进行分割 -
String.strip(["str"])
在字符串前后删除空格,或者删除“str”
-
-
-
列表:
- 列表可以保存任意的数据类型
- 列表可以使用切片
- 列表是可变的,字符春不可变
- 可以创建空列表,也可以创建只有一个元素的列表
- 可以创建多维列表
-
列表的遍历:
使用for in 遍历 arr = [1,2,3,4,5] for i in arr: print(i) //输出遍历的元素 print(arr.index()) //输出遍历的下标 使用enumerate遍历 for i,val in enumerate(arr): print(i) //下标 print(val) //值
在用enumerate()遍历列表时,将列表转换为(index,val),(index,val)…的序列
-
深拷贝和浅拷贝
浅拷贝: import copy arr1 = [[1,2],[3,4]] arr2 = copy.copy(arr1) arr1[0][0] = "a" print(arr2) 深拷贝: import copy arr1 = [[1,2],[3,4]] arr2 = copy.deepcopy(arr1) arr1[0][0] = "a" print(arr2)
-
arr.append("a")
在列表最后插入元素 -
arr.insert(num,"a")
在下标为num的元素之后插入元素,如果找不到这个下标,就默认在列表最后插入元素 -
arr.extend(list1)
将两个列表进行合并 -
arr.count(item)
查看某个元素出现的次数 -
arr.index(item)
查看某元素在列表中的第一个下标,如果不存在报异常 -
arr.pop()
删除最后一个元素 -
arr.remove(item)
删除列表中的元素,如果有多个就删除第一个 -
arr.reverse()
将列表元素反转 -
arr.sort()
列表排序,默认升序,降序排序arr.sort(reverse = True)
-
arr.copy()
浅拷贝 -
arr.clear()
清空列表
-
元组(运行效率高):
元组与列表类似,但是元组的元素不可改变
可以使用切片
可以定义只有一个元素的元组,mytuple=(1,) 逗号不可少
可以定义空元组
- 操作list\tuple的内建函数:
len(list)
列表长度max()
最大值min()
最小值list()
将元组转换为列表tuple()
将列表转换为元组enumerate()
返回下标和元素
- 操作list\tuple的内建函数:
-
字典:
键值对
-
创建方式:
-
json格式创建
mydict = {"name":"小白"}
-
通过内建函数创建
mydict = dict(name = "小红",age = 10) print(mydict) mydict = dict(zip([键名],[值])) exm: mydict = dict(zip(["name","age"],["小绿",18])) 可迭代对象方式: mydict = dict([("name","小爱"),("age",17)])
-
字典内建方法:
mydict = dict.fromkeys(["name1","name2"],"小宝") //批量创建
-
-
访问方式:
mydict[键名]
-
遍历字典:
-
字典内建函数:
dict.get("key","info")
返回key对应的value 没有为none 输出提示信息 infodict.keys()
返回字典中的所有键doct.values()
返回字典中所有的值dict.item()
返回字典中所有的键值对dict.setdefault(key,value)
添加数据dict.pop()
删除keydict.popitem()
删除最后一位的键值对dict.clear()
清空字典
-
-
集合:
唯一的不可变的对象的一种无序集合,集合中的元素不可重复
-
集合的创建:
myset = set("abc") myset = set([1,2,3,4,5,6])
-
集合的添加:
set.add("abc") //添加一项 set.update("abc") //添加多项
-
集合的删除:
set.remove("b") //删除某项
-
差集:
myset1 - myset2
-
并集:
myset1 | myset2
-
交集:
myset1 & myset2
-
运算符:
算术运算符:+ - * / % // **
- 在python3中,除法无论有无复杂类型,结果都精确到浮点数
+
操作两个数字型数据是加法运算+
操作一个数字型数据代表正数+
操作str list tuple 起到了连接作用-
操作两个数字型数据是减法运算-
操作一个数字型数据代表负数*
操作两个数字型数据是乘法运算*
操作一个数字型数据代表正数*
操作str list tuple 起到了重复的作用%
取余**
幂运算
逻辑运算符:
and
与or
或not
非
关系运算符:
==
等于,比较对象是否相等!=
不等于,比较对象是否不相等>
大于<
小于>=
大于等于<=
小于等于
位运算符:
&
按位与运算符,参与运算的两个数,如果两个相应都为1,该位结果为1,否则为0|
按位或运算符,只要对应的两个二进位有一个为1,结果位数为1^
按位异或运算符,当两对应的二进位相异时,结果为1~
按位取反运算符,对数据的每个二进制位取反,即把1变为0,0变为1<<
左移运算符,运算数的各二进制位全都左移若干位,由<<右边的数字决定左移位数,高位丢弃,低位补0>>
右移运算符,运算数的各二进制位全都右移若干位,由>>右边的数字决定右移位数,高位丢弃,低位补0
赋值运算符:
=
等于+=
加等于-=
减等于*=
乘等于/=
除等于%=
求余等于**=
幂等于//=
地板除等于(向下取整)
成员运算符:
in
判断某元素是否存在序列中,返回布尔值not in
判断某元素是否不存在序列中,返回布尔值
身份运算符:
is
是否指向同一个地址is not
是否不指向同一个地址
运算符优先级:
幂运算,正负,算术运算符,关系运算符,赋值运算符,身份运算符,成员运算符,逻辑运算符
流程控制:
分支结构:
if 条件:
执行语句
elif 条件:
执行语句
else:
执行语句
三元运算:
结果1 if 表达式 else 结果2 表达式成立就返回结果1,不成立返回结果2
range(start,end,step):
创建从start到end 的序列 step代表步进值
函数:
将完成某一特定功能的代码集合起来,并且能够重复调用的代码块
函数的声明:
def 函数名(形参):
函数体
return
函数名(实参)
定义参数:
1.默认参数(缺省参数)
def fn(a=10):
print(a)
fn()
2.可变参数
def fn(*arr):
print(arr)
fn(1,2,3,4,5)
输出结果为:(1,2,3,4,5) //是一个元组
3.关键字参数
def fn(name,age=10,**attr):
print("name:%s"%name)
print("age:%s"%age)
print(attr)
fn(name="xb",age=10,sex="nan",tel=123456)
输出结果为:
name:xb
age:10
{"sex":"nan","tel":123456} 多余参数由一个字典型数据接收
4.参数组合
必选参数->默认参数->可变参数->关键字参数
匿名函数:
lambda 参数:表达式(只有一行的函数体)
他可以有多个参数
表达式不需要返回值,自动return
调用方式(自调用):
num = (lambda a,b:a+b)(10,20)
print(num)
fn = lambda a,b:a+b
print(fn(10,20))
高阶函数:
-
map(函数,序列) 让序列中的每一个元素都执行这个函数
arr = map(lambda x, y:x+y,range(0,10),range(0,10)) print(list(arr))
-
filter(函数,序列) 让序列中的每一个符合函数要求的元素返回出来
arr = filter(lambda x:x>5,range(0,10)) print(list(arr))
-
reduce(函数,序列) 不常用的,包的引入
import functools //不常用的库 res = functools.reduce(lambda x,y:x+y,range(1,11)) //累加 print(res)
局部变量与全局变量:
global语句:不能在声明的同时赋值,使用了global语句之后不能在局部再声明这个变量
global并不是一个类型或大小的声明,是一个命名空间的声明,它告诉python函数大蒜生成一个或多个的全局变量名,它存在于整个模块内部作用域(命名空间)的变量名
aa = 123
def fn():
global aa
aa = 456
fn()
print(aa) //结果为456,修改了全局变量
nonlocal语句:
num = 123
def aa():
num = 456
def bb():
nonlocal num
num += 10
bb()
print(num)
aa()
闭包函数:
在函数中可以(嵌套)定义另一个函数时,如果内部函数引用了外部函数的变量,就可能产生闭包
作用:闭包可以用来在一个函数与一组“私有”变量之间创建关联关系,在给定函数被多次调用的过程中,这些私有变量能够保持其持久性
def aa():
num = 10
def bb():
print(num)
return bb
bb = aa()
bb()
递归函数:
一个函数在内部不调用其他的函数,而是调用自己本身,这就是递归函数
def aa(num):
if num == 1:
return 1
else:
return num * aa(num-1)
print(aa(10))
装饰器:装饰器的调用顺序是由里到外的
装饰器实际上就是为了给某程序添加功能
-
使用场景:比如该程序已经上线或已经被使用,name就不能大批量的修改源代码。
-
装饰器三原则:
- 不能修改被装饰的函数的源代码
- 不能修改被装饰的函数的调用方式
- 满足前两个的情况下给程序添加新功能
-
装饰器的定义公式
<函数+实参高阶函数+返回值高阶函数+嵌套函数+语法糖=装饰器> import time //导入time包 def tester(fn): def newtest(): start = time.time() //获取当前时间 fn() end = time.time() print("运行总时间:%s"%(end - start)) return newtest @tester def test(): time.sleep(1) //程序休眠1秒钟 print("test is running!") //test = tester(test) test()
函数的柯里化:
def add(a):
def fn(b):
print(a+b)
return fn
add(5)(4) //add(5)fn(4)
补充:
容器 迭代对象 迭代器 生成器
容器 = 变量(存储数据)
迭代对象:可迭代的对象
字符串 列表 字典 集合 元组 优势:节省内存,提高迭代效率
迭代器:生成迭代对象
a = iter(“abc”) 关键字iter生成迭代对象
next(a) 关键字next调用迭代对象
生成器:特殊的迭代器
快速生成迭代对象
#遇见yeild关键字时,程序不往下执行,相当于return 下一次调用next时再从停下不执行的位置开始执行。
# 指定数量的斐波那契数列
def myList(num):
a = 0
b = 1
c = 0
while c<num:
yield b
a,b = b,a+b
c += 1
print(list(myList(10)))
# 协程开发(循环输出1,2,3)
def aaa():
while True:
print(1)
yield
def bbb():
while True:
print(2)
yield
def ccc():
while True:
print(3)
yield
a = aaa()
b = bbb()
c = ccc()
import time
while True:
time.sleep(1)
next(a)
time.sleep(1)
next(b)
time.sleep(1)
next(c)
协程:浪费资源最少,只能处理小型的任务
在同一个线程内完成轮询
进程:计算密集型(充分调用CPU的计算能力)
处理并发 (同时开启多个进程完成轮询)
线程:io密集型任务
处理并发 一个进程内的多个线程完成轮询(同时只能有一个线程在执行) (python的线程并行,即多线程是假的)
并行:
同时能做多少事情 ex:6核CPU同时能开启6个进程
并发量:
同时能够容纳任务的极限 ex:6核CPU运行30个任务,并发量为5