Python基础知识
2019-03-10 11:52:58来源：博客园 阅读 ()
print()
print 参数：end 默认为 换行，即end = "\n"
可以不换行，即 end = ""
或指定结束，即 end = "abc"
#内建函数
"""
注释
"""
?
占位符：
-
%d 整数
-
%f 浮点型 %0.1f 保留一位
-
%s 字符串
包裹：
import copy #引入copy包裹
import random #引入random包裹
import functools #引入functools包裹，不常用的函数
import time
import os 系统 os.system("cls")
import os.path
import pickle
import csv
?
from urllib.request import *
import re
?
import tkinter as tk
os:
-
os.system() 命令行控制台
-
os.listdir() 显示目录下的内容
-
os.mkdir() 创建文件夹
os.path:
-
os.path.isfile() 是否为文件
-
os.path.isdir() 是否为路径
内建函数：
-
print（）
-
input（）
-
type（）
name = input("名字")
print(name,":",type(name))
?
名字123
123 : <class 'str'>
? -
float（）
-
int（）
-
bin（）
-
hex（）
-
oct（）
-
id（）查看变量的地址
-
range(start,end,step) 创建序列 start 开始， end 结束， step 步进值
-
ord('A') 转化单个字母
-
chr(97) 'a' 转化为字符串
-
name='张三'
name.encode('utf8')
int.from_bytes(name.encode('utf8'),xxxx='big') -
变量：
-
变量不需要先声明，直接赋值，直接使用
-
同时给多个变量赋值
-
命名：数字字母下划线组成，不能以数字开头，区分大小写，不能使用$
-
不支持 自增自减 a += 1;
-
变量名不可以是 关键字和保留字
数据类型：
1. 数字
-
整数
0b开头，二进制；0o开头，八进制；0x，十六进制；科学计数法，8e2 = 800
-
浮点数
-
复数：虚部以 j 或 J 结尾的为复数
2. 字符串
-
单引号
-
双引号
-
三引号：1.多行注释；2. 实现 多行输出
-
转义字符：\
#1.前缀 r
print(r"\n\r\t")
#输出 \n\r\t
#2.前缀 b
#代表后面的字符串是byte数据。在python2中 print函数操作的字符串全部为byte型数据
# python3中 是Unicode数据
#3.前缀 u
#代表后面的字符串是Unicode数据。python2为了兼容python3 -
【**】切片
str1 = "山西优逸客"
print（str1[开始下标：结束下标：步进值]）
默认 0 ： 最后 ：1
print（str1[：：-1]） -
字符串的内建函数：
1. String.capitalize()：把字符串的第一个字符大写
2.String.lower()：小写
3.String.upper()：大写
4.扩充：
String.center(扩充后的长度，扩充的方式) String在中间，即 在两边填充
String.ljust(扩充后的长度，扩充的方式) String在左边，即 在右边填充
String.rjust(扩充后的长度，扩充的方式) String在右边，即 在左边填充
5.String.count("str",start,end)：在start到end之间 str 的次数
6.String.encode(encoding="utf-8",errors="ignore")：编码 encoding="utf-8"/"gbk"/"gb2312"
7.String.decode(encoding="utf-8",errors="ignore"[错误 忽略])：解码
8.String.endswith(”0“)：是否是以 0 结尾，填写字符串
9.String.find(str,start,end)：在start到end之前 str 的下标。没有返回-1
10.String.rfind(str,start,end)：在start到end之前 str 的下标
11.String.index(str,start,end)：在start到end之前 str 的下标。没有 报异常
12.String.isalnum()：至少有一个字符，所有字符为数字或字母。为True
13.String.isalpha()：至少有一个字符，所有字符为字母。为True
14.String.isdecimal()：是否字符串都是十进制数字
15.String.isdigit()：是否字符串都是数字
16.String.islower()：是否字符串都是小写
17.String.isupper()：是否字符串都是大写
18.String.isspace()：至少有一个字符，并且String全为空
19.String.join(seq)：将列表对象用String转化为字符串
arr = ["1","2","3","a","b"] #必须为字符串才能用 join
",".join(arr)
#输出结果：1，2，3，a，b20.String.split(",",num)
str1 = "1,2,3,4,5,6"
str1.split(",") # ["1","2","3","4","5","6"]
str1.split(",",2) # ["1","2","3,4,5,6"]21.String.splitlines()：将字符串通过\n进行分割
22.String.strip(["srt"])：将字符串前后空格删除，或者删除str
str2 = " 13 "
print(len(str2))
str3 = str2.strip()
print(len(str3))
str4 = str3.strip("1")
print(len(str4))
str1 = "1_2_3,4,5\n6"
print(str1.splitlines())
?
#输出结果
9
2
1
['1_2_3,4,5', '6']
3.列表
-
列表语法：mylist=[1,2,3,4]
-
注意：
-
列表可以保存任意类型数据
-
列表可以使用切片
-
列表是可变的，字符串不可变
-
可以创建空列表，也可以创建只有一个元素的列表
-
可以创建多维列表
-
-
-
列表的遍历 for item in arr:
for item in mylist:
print(mylist.index(item),end=" ")
print(item)
#
for i,v in enumerate(mylist):
print(i)
print(v)
#enumerate(mylist)：将列表转化为（index,item）序列 -
深拷贝与浅拷贝
import copy #引入copy包裹
?
copy.copy(arr) #浅拷贝 里面变化
copy.deepcopy(arr) #深拷贝 一直不变 -
列表内建函数
List.append() 在最后插入一个元素
List.insert(10,"a") 在任意位置插入元素
List.extend([4,5,6]) 合并两个 list 数据
print(arr + [4,5,6] + [7,8,9]) #合并多个
List.count(item) 查看某元素在list的次数k
List.index(item) 查看item在list中的第一个下标。没有 则 报异常
List.pop() 删除最后一个元素
List.remove(item) 删除列表中的元素，有相同的删除第一个
List.reverse() 将list反转
List.sort(reverse=True) 排序 默认为升序 reverse=True 降序
List.copy() 浅拷贝
List.clear() 清空数组 -
推倒式（python 特有的写法 语法糖）
arr1=['1','2','3','4']
arr2=[item for item in arr1 if item=='3'] #
print(arr2) # ['3']
4.元组
-
mytuple=(1,) 定义一个加，
-
可以定义空元组 不可以改变
mytuple=([],[]) 可以改变 可以使用数组的一些方法
-
注意：
-
元组元素不可改变
-
通过圆括号定义
-
可以使用切片
-
定义一个元素的元组，逗号不可少
-
空元组
-
操作list\tuple的内建函数
-
len(list)数组的长度
-
max()数组的最大数
-
min()数组的最小数
-
list()将元组转换为列表
-
tuple()将列表转换为元组
-
enumerate()返回下标和元素
5.字典
-
创建方式
1.json格式创建
a = {"name":"小白"}
2.通过内建函数
b = dict(name="小红"，age=10)
3.通过映射函数的方式
c = dict(zip(["name","age"],["小红"，"10"])) #映射函数
4.可迭代对象的方式
d = dict([("name","小红")，("age",10)]) -
如何批量创建：
mydict = dict.fromkeys(["name1","name2"],"小白")
print(mydict)
#输出结果
#{'name1': '小白', 'name2': '小白'} -
字典的访问：mydict[键]
-
删除：del mydict[键]
-
mydict.clear () 清空
-
mydict.keys () 键名
-
mydict.values () 值
-
mydict.items () 键名：值
-
mydict.setdefault ("键名"，值) 添加
-
mydict.pop() 删除
-
mydict.popitem() 删除最后一位的key:value
-
mydict.get("key","info") 存在key，返回key对应的value。不存在key，返回信息 info
数据类型的转化：
-
float（） 转化为浮点型
-
int（） 转化为整型
-
bin（）将十进制转化为 二进制
-
oct（）将十进制转化为 八进制
-
hex（）将十进制转化为 十六进制
集合：
-
唯一的、不可变的
-
创建：
myset = set([1,2,3])
myset = set("abc") -
添加：
myset.add("de") #{"a","b","c","de"}
myset.update("de") #{"a","b","c","d","e"} -
删除：
myset.remove("d") -
列表去重
list1 = [1,2,3,4,4,5]
list2 = list(set(list1)); -
差集（-）、交集（&）、并集（|）
运算符：
-
算数运算符：
-
基本算数运算符：+ - * /
注意：Python3中，除法无论有无复杂类型，结果都精确到 浮点数
+ 操作两个数字型数据 --- 加法
+ 操作一个数字型数据 --- 正数
+ 操作str / list / tuple --- 拼接
- 和负数 --- 加法运算
* 操作两个数字型数据 --- 乘法
*n 操作str / list / tuple --- 重复n次
-
// 除 结果为 int
-
% 取余
-
** 幂运算
-
-
逻辑运算符
-
and 与
-
or 或
-
not 非
-
-
关系运算符：
#js 动态类型 弱类型的语言（隐式转换）
#python 动态类型 强类型的语言（不会转化类型）-
== 等于
-
!=不等于
-
“> 大于
-
< 小于
-
">= 大于等于
-
<= 小于等于
-
-
位运算符：
-
&：按位与，两个位 数都为1，按位与结果为1.否则为0；
-
|：按位或，两个位 数只要有一个为1，按位或结果为1.否则为0；
-
^：按位异或，两个对应的二进位相异时，结果为 1 。相同为 0；
-
~：按位取反，0为1，1为0；
-
<< n：左移n位
-
''>> n：右移n位
-
-
赋值运算符：
-
=
-
+=
-
-=
-
*=
-
/=
-
%=
-
//=
-
**=
-
-
成员运算符：
-
in
arr = [1,2,3]
print(i in arr) #True -
not in
-
-
身份运算符：
-
is 判断id地址是否一样，即 为同一个
num1 = 123;
num2 = 123;
print(num1 is num2) #True -
is not
-
运算符优先级：
幂运算、正负、算数运算符、关系运算符、赋值运算符、身份运算符、成员运算符、逻辑运算符
-
** 指数 (最高优先级) ~ + - 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) */ % // 乘，除，取模和取整除 + - 加法减法 >> << 右移，左移运算符 & 位 'AND' ^ | 位运算符 <= < > >= 比较运算符 <> == != 等于运算符 = %= /= //= -= += *= **= 赋值运算符 is is not 身份运算符 in not in 成员运算符 not and or 逻辑运算符
分支语句：
if 1>2:
print("1>2")
elif 2==1:
print("2=1")
else:
print("1<2")
?
结果1 if 表达式 else 结果2
print(1 if 1>2 else 2) #输出结果：2
循环语句：
-
for
for i in range([start,] end [,step]):
print(i)
?
?
for i in range(1,10):
str1 = ""
for j in range(1,i+1):
if (j==2 and i==3)or(j==2 and i==4):
str2 = " "
else:
str2 = " "
str1 += str(j) + "*" + str(i) + "=" + str((i*j)) +str2
print(str1)
?
for i in range(1,10):
for j in range(1,i+1):
print("%d*%d=%d"%(j,i,i*j),end=" ")
print("") -
while
import random
num = random.randint(0,100)
?
s = 0
while True:
if s<5:
num1 = int(input("请输入0-100的数字："))
s += 1
if num1 > num:
print("大了一点")
elif num1 < num:
print("小了一点")
else:
print("恭喜你！")
break
?
else:
print("你输了！")
break
循环终止语句：
-
continue：
-
break：
函数：
-
定义：def
def add(a,b):
print(a,b) # 30,20
return a+b
?
print(add(b=20,a=30)) # 50
-
默认参数：
def add(a=10,b):
print(a,b)
return a+b
?
print(add(b=20))
-
可变参数：*arr
def aa(*arr):
print(arr)
aa(1,2,3,4,5)
# 输出结果 （1，2，3，4，5）元组
-
关键字参数：**attr
def person(name,age=20,**attr):
print("name:%s"%name)
print("age:%s"%age)
print(attr)
person(name="xb",age=18,sex="男",tel=123456) #name:xb age:18 {'sex':'男'，'tel':123456}
person(name="xb", sex="男", tel=123456) #name:xb age:20 {'sex':'男'，'tel':123456}
person("xb", sex="男", tel=123456) #name:xb age:20 {'sex':'男'，'tel':123456}
-
参数的定义顺序：必选参数、默认参数、可变参数、关键字参数
def person(name, age=20,*cj, **attr):
print("name:%s" % name)
print("age:%s" % age)
print(cj)
print(attr)
person("xb",68,78,84,92, sex="男", tel=123456)
#输出结果：
name:xb
age:68
(78, 84, 92)
{'sex': '男', 'tel': 123456}
返回值：return
yield #将函数的返回内容 装进生成器对象里面
# 求指定数字个数的斐波那契数列
def math4(num1):
p=0
q=1
c=0
while c<num1:
yield q
p,q=q,p+q
c+=1
?
print(list(math4(20)))
高阶函数：
-
实参高阶函数： 当作形参传入
-
返回值高阶函数： 返回值为一个函数
def add(a,b):
return a+b
def sub(a,b):
return a-b
def size(a,b,fn):
return fn(a,b)
?
print(size(10,20,add)) #实参高阶函数 30
print(size(10,20,sub)) #实参高阶函数 -10
#返回值高阶函数
def fn():
def aa():
print("这是一个函数")
return aa
?
bb = fn()
bb()
?
空函数：pass
def fn():
pass
匿名函数：lambda
lambda 参数 : 函数体（一行）
1.可以有多个参数
2.不需要 return，自动return
?
调用：
1.自调用
print( (lambda a,b:a+b)(10,20) ) #30
2.字面量
fn = lambda a,b:a+b
print( fn(10,20) ) #30
?
常用的使用场合：map、reduce、filter
map(函数，序列)
序列里面的每个都执行函数，返回 map 对象
arr = map(lambda x:x*2,range(1,11))
print(list(arr))
#[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
?
arr = map(lambda x,y:x+y,range(1,11),range(0,10))
print(list(arr))
#[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
?
?
arr1 = map(lambda x,y:x+y,range(1,11),range(0,5))
print(list(arr1))
#[1, 3, 5, 7, 9]
filter(函数，序列)
筛选符合 函数表达式的，返回 filter 对象
arr = filter(lambda x:x>5,range(1,11))
print(list(arr))
#[6, 7, 8, 9, 10]
reduce(函数，序列)
x指上一次执行的结果，可变的。y指每一次的序列值。返回一个值
import functools
num = functools.reduce(lambda x,y:x+y,range(1,11))
?
# x:0 y:1
# x:1 y:2
# x:3 y:3
# x:6 y:4
?
print(num)
作用域：
-
注意：全局变量 在局部，只能访问，不能 修改
-
关键字：global aa #aa 为想要改变的全局变量
相当于 声明。不能直接 赋值 进行改变
aa = 123
def fn1():
global aa,bb
aa = 456
bb = 50
fn1()
print(aa,bb) # 456
1. 改变全局变量 eg:aa
2. 声明全局变量 eg:bb
-
关键字：nonlocal aa
num1 = 123
def fn1():
num1 = 456
def fn2():
nonlocal num1
num1 += 10
fn2()
print(num1)
fn1() # 466
闭包函数：
在函数中 可以定义另一个函数时，如果内部函数引用了外部函数的变量，并且调用内部函数，则 产生闭包
作用：
1.在一个函数与一组私有变量之间创建关联关系； 2.在给定函数被多次调用的过程中，这些私有变量保持持久性。
def aa():
num1 = 456
def bb():
print(num1) # 作用2
return bb
?
b = aa()
b() # 456 # 作用1
递归函数：
def f(num):
if num==1:
return 1
else:
return f(num - 1)*num
?
print(f(5))
装饰器：
为了给某程序增添功能
**理解：把需要改变的函数 当作 参数 传入新的函数中，让新的函数完成添加的功能。
最后 让 原函数名 等于 新函数 的返回值【返回值为一个函数】
-
三个原则：
-
不能修改被装饰的函数的源代码
-
不能修改被装饰的函数调用
-
满足1、2的情况下给函数添加新功能
-
-
装饰器定义公式：
函数 + 实参高阶函数 + 返回值高阶函数 + 嵌套函数 + 语法糖（@tester）= 装饰器
import time
?
# 装饰器，添加新功能
def tester(fn):
def newtest():
start = time.time() #记录时间的函数
fn() #不修改被装饰的函数调用
end = time.time()
print("总时间：",end-start)
return newtest
?
# 源程序
def test():
time.sleep(1) #程序休眠 1 秒
print("test is running")
test = tester(test) # 源程序为“装饰”之后的。名字可以任意
test()@函数名：把后面的 当作参数 传入
import time
?
# 装饰器，添加新功能
def tester(fn):
def newtest():
start = time.time() #记录时间的函数
fn() #不修改被装饰的函数调用
end = time.time()
print("总时间：",end-start)
return newtest
?
-
加入参数：
按照需求往外加函数
实质：从里到外 调用
import time
?
装饰器，添加新功能
?
def tester1(a,b)
?
def tester(fn):
?
def newtest():
?
start = time.time() #记录时间的函数
?
fn() #不修改被装饰的函数调用
?
end = time.time()
?
print("总时间：",end-start)
?
print("参数："，a,b)
?
return newtest
?
retuen tester
?
文件操作：
读文件：open
open(文件路径,打开文件模式,encoding = "utf-8",errors = "ignore")
#1.读操作
f = open("note.txt","r") #文件的对象
con1 = f.read([num]) #num代表读取字符数量,默认为全部
con2 = f.readline([num]) #文件读取每一行,通过\r \n EOF（文件结束标识）。num代表读取一行的几个字符
con3 = f.readlines() #返回列表形式
f.close()
print(con) # 山西太原
?
#2.写操作
f = open("note.txt","w")
f.write(str) 把str写入文件,不会在str后加入换行符
f.writelines(arr) 把arr写入
打开文件模式：
r 读操作（默认） rb 以二进制的方式读取
w 写操作 每次执行重头开始写入，路径不对会创建新文件 【因为 打开 指针指向开始】
a 追加 每次执行直接添加，路径不对会创建新文件【因为 打开 指针指向结尾】
r+ 读写，不创建新文件，每次读写在文件开头
w+ 读写，创建新文件，每次读写会覆盖文件内容
a+ 读写，创建新文件，每次读写追加
?
f.seek():移动 文件读取指针到指定位置
f.seek(p,0) 开始，移动到文件第p个字节处，绝对位置
f.seek(p,1) 当前位置，移动到相对于当前位置之后的p个字节（文件以二进制方式打开）
f.seek(p,2) 结尾，移动到相对文章尾之后的p个字节（文件以二进制方式打开）
【p为偏移量】
f.tell():返回文件读取指针位置
f.flush():把缓冲区的内容写入硬盘
f.close():1.把缓存区的内容写入硬盘；2.关闭文件
try:
f = open("note2.txt","r") #捕获异常。
except: #发生异常时执行；
print("发生错误")
try:
f = open("note2.txt","r") #捕获异常。
finally: #无论发不发生异常都执行；
if f: #如果f文件存在
f.close() #关闭文件
with open("note2.txt","r") as f: #用完自动关闭文件
f.read()
pickle：默认存储方式为二进制
-
pickle.dump(obj,f)
-
obj = pickle.load(f)
import pickle
# obj = [{"name":"小白","sex":"男","age":20}]
# with open("note.txt","wb") as f:
# pickle.dump(obj,f)
with open("note.txt","rb") as f:
obj = pickle.load(f)
print(obj[0])
csv：存储数据
import csv
with open("demo.csv","w"[,newline=""]) as f:
writer = csv.writer(f,dialect="excel")
for i in range(10):
writer.writerow([1,2,3,4,5])
with open("demo.csv","w"[,newline=""]) as f:
writer = csv.writer(f,dialect="excel")
writer.writerows([[1,2,3,4,5],[6,7,8]]) #创建多行
writer1 = csv.DictWriter(f,["id","name","sex","tel"])
writer1.writerheader()
?
with open("demo.csv","r") as f:
reader = csv.reader(f)
print(list(reader))
#
[['1', '2', '3', '4', '5'], [], ['1', '2', '3', '4', '5'], [], ['1', '2', '3', '4', '5'], [], ['1', '2', '3', '4', '5'], [], ['1', '2', '3', '4', '5'], [], ['1', '2', '3', '4', '5'], [], ['1', '2', '3', '4', '5'], [], ['1', '2', '3', '4', '5'], [], ['1', '2', '3', '4', '5'], [], ['1', '2', '3', '4', '5'], []]
?
with open("demo.csv","r") as f:
reader = csv.DictReader(f)
for item in list(reader):
print(dict(item))
#
{'1': '1', '2': '2', '3': '3', '4': '4', '5': '5'}
{'1': '1', '2': '2', '3': '3', '4': '4', '5': '5'}
{'1': '1', '2': '2', '3': '3', '4': '4', '5': '5'}
{'1': '1', '2': '2', '3': '3', '4': '4', '5': '5'}
{'1': '1', '2': '2', '3': '3', '4': '4', '5': '5'}
{'1': '1', '2': '2', '3': '3', '4': '4', '5': '5'}
{'1': '1', '2': '2', '3': '3', '4': '4', '5':