Python基础
Python介绍
Python基本使用
基本语法
转义字符
- \t 制表符
- \n 换行
- \r 覆盖（\r后的字符完全覆盖前面的字符）
- \b 退格
二进制与字符编码
print(chr(0b101011010),ord('池'),ord('世'),ord('勋'))
#chr(0b***),二进制转换为字符
#ord(''),字符转二进制
#Ś 27744 19990 21195
python标识符和保留字
查询保留字
import keyword
print(keyword.kwlist)
#['False', 'None', 'True', '__peg_parser__', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
变量
变量的标识符存储的是地址
name='玛丽亚'
print('标识(地址)',id(name))
print('类型',type(name))
print('值',name)
#标识 1621377053104
#类型 <class 'str'>
#值 玛丽亚
被多次赋值，会指向最新的变量空间
基本数据类型
- 整型
默认十进制
二进制（0b）
八进制（0o）
十六进制（0x）
- 浮点型
from decimal import Decimal
a = 1.1
b = 2.1
print(a + b) #二进制引起的问题
print(Decimal('1.1') + Decimal('2.1'))
字符串
python没有字符，一个字符就是长度为一的字符串
-
三引号（‘’‘）或（“ ” “）可以换行
-
转义字符 \
-
在字符串前加上r可以取消转义
print('hello\t world') #hello world print(r'hello\t world') #hello\t world -
级联字符串？？
-
字符串截取
字符串索引可以从左到右以0开始，可以从有到左以-1开始
str = 'hello world' print(str) print(str[0:-1]) #截取从第一个到最后一个，不包含最后一个 # hello worl print(str[3]) #输出第四个字符 #l print(str[1:])#输出2个之后的所有字符 #ello world print(str[:3])#输出第四个之前的所有字符 #hel print(str[1:-1:3])#输出第二个到最后一个字符之前，每隔三个一输出 #eoo
字符串格式化：
print()函数中，可以通过加%进行格式化：
print("%s"%("str"))
列表
元素类型可以不同
操作基本同字符串
list中的元素可以改变
def reverseWords(input):
# 通过空格将字符串分隔符，把各个单词分隔为列表
inputWords = input.split(" ")
# 翻转字符串
# 假设列表 list = [1,2,3,4],
# list[0]=1, list[1]=2 ，而 -1 表示最后一个元素 list[-1]=4 ( 与 list[3]=4 一样)
# inputWords[-1::-1] 有三个参数
# 第一个参数 -1 表示最后一个元素
# 第二个参数为空，表示移动到列表末尾
# 第三个参数为步长，-1 表示逆向
inputWords = inputWords[-1::-1]
# 重新组合字符串
output = ' '.join(inputWords)
return output
if name == “main”:
input = 'hello world'
rw = reverseWords(input)
print(rw)
- **Tuple（元组）**
与列表相似，用小括号定义，元素不可更改
```python
tup1 = () # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号
-
Set（集合）
集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
创建格式：
parame = {value01,value02,...} 或者 set(value)集合的应用
sites = 10 n1 = 10 str1 = 'hello world' set1 = {sites, 'bobo', n1, str1, 10, 20, 'hello world'} print(set1) ''' {10, 'bobo', 20, 'hello world'} 会自动消除重复元素，只要输出相同，都会被去掉 ''' # 测试成员是否在集合中 if 20 in set1: print('10在集合中') else: print('10不在集合中') if str1 in set1: print('ste1在集合中') else: print('str1不在集合中') ''' 可通过变量名判断是否在集合中 只要输出为10，都会认为在集合中 ''' # set可以进行集合运算 a = set('hello world c') b = set('what are you doing b') print(a) print(b) print(a - b) # a,b的差集 print(b - a) print(a | b) # a,b的并集 print(a & b) # a,b的交集 print(a ^ b) # a,b中不同时存在的元素 -
Dictionary（字典）
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。
示例
dict={} dict[1]='one' dict['one']=1 print(dict) dictionary={1:'one','one':1} print(dictionary) {1: 'one', 'one': 1} {1: 'one', 'one': 1} -
数据类型转换
函数 描述 [int(x [,base])] 将x转换为一个整数 [float(x)] 将x转换到一个浮点数 [complex(real [,imag])] 创建一个复数 [str(x)] 将对象 x 转换为字符串 [repr(x)] 将对象 x 转换为表达式字符串 [eval(str)] 用来计算在字符串中的有效Python表达式,并返回一个对象 [tuple(s)] 将序列 s 转换为一个元组 [list(s)] 将序列 s 转换为一个列表 [set(s)] 转换为可变集合 [dict(d)] 创建一个字典。d 必须是一个 (key, value)元组序列。 [frozenset(s)] 转换为不可变集合 [chr(x)] 将一个整数转换为一个字符 [ord(x)] 将一个字符转换为它的整数值 [hex(x)] 将一个整数转换为一个十六进制字符串 [oct(x)] 将一个整数转换为一个八进制字符串
运算符
-
‘is’ ‘==’
都有比较是否相等的功能，is会判断是否引用了同一个对象a=10 b=10 #此时a，b引用了同一个对象，id返回的地址是一样的，用 is 返回的结果为True b=100/10 #此时a,b不再引用统一对象，is返回为false，==返回为true b=10 #此时a,b又引用了同一对象，is返回结果为true -
’and’ ‘or’ 'not’
a=10 b=10 if a and b: print('1-变量a,b都为true')
if 1 and 2:
print(‘2-只要不为0则都认为是true’)
if 1 and -1:
print(‘3-负数也同样为ture’)
r=complex(1,1,)
if 1 and r:
print(‘4-复数也认为是true’)
- **位运算符**
python中位运算符都是将数字转换为二进制后，再分别对比每一位来计算
```python
a = 10
b = 12
print(bin(a), bin(b))
# & 比较二进制的每一位，对应为为返回1，否则为0
print('&',a & b, bin(a & b)) # 1010 & 1100 = 8(1000)
# | 比较每一位，对应位置有一个是1返回1
print('|:',a | b, bin(a|b)) # 1010 & 1100 = 14 1110
# ~ 计算机存储采用补码形式，a先以二进制数变成补码，正整数的补码不变（0）1010，之后对每一位取反，（1）0101，再将其转换为补码形式，负数转换补码，取反后再加1，（1）1010+1=（1）1011
print(~a, bin(~a))#-11 -0b1011
print(~b, bin(~b))#-13 -0b1101
print( )函数的使用
1.控制台输出
- 输出数字
- 输出字符串
- 输出含有运算符的表达式
2.文件输出
#file=**，才会将字符添加到文件中，否则只会创造文件
fp=open('D:/Python/test/text.txt','a+')#'a+'会在该目录查找文件，没有则创建
print('hello world',file=fp)
fp.close()
换行用逗号隔开
不换行加上end=“”
input()的使用
improt
在 python 用 import 或者 from…import 来导入相应的模块。
将整个模块(somemodule)导入，格式为： import somemodule
从某个模块中导入某个函数,格式为： from somemodule import somefunction
从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入，格式为： from somemodule import *
函数
**格式：
def 函数名（参数列表）：
函数体
**
在Python中类型是属于对象的，变量没有类型
a = [1, 2, 3]
# a是指向list类型对象[1,2,3]的标识，指针
a = "String"
# 此时a又是指向String类型的指针
对象分为可更改对象(mutable) 和 不可更改对象(immutable)
可更改对象：List、dict
- 可更改类型: 变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。
不可更改对象：String、tubles、numbers
- 不可变类型： 变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变 a 的值，相当于新生成了 a。
不可变对象在被当作参数传递给函数时，只是将值传递了进去，其本身并没有影响，如
def id_test(a, b):
print("函数内不可更改类型a的标识：", id(a)) # 函数内不可更改类型a的标识： 2474474039888
a = 0
print("对不可更改变量a赋值后a的标识：", id(a)) # 对不可更改变量a赋值后a的标识： 2474474039568
print("可更改类型b的标识：", id(b)) # 可更改类型b的标识： 2474475795584
b[0] = a
print("对可变类型中部分操作后的id：", id(b)) # 对可变类型中部分操作后的id： 2474475795584
a = 10
print(a)
b = [10, 11, 12]
print("函数外不可变：", id(a)) # 函数外不可变： 2474474039888
print("函数外可变：", id(b)) # 函数外可变： 2474475795584
id_test(a, b)
print(a)
print(b)
匿名函数
lambda 形参：返回值
lambda函数能接收任何数量的参数但只能返回一个表达式的值
匿名函数作为实参
例子：用同一个函数对两个数实现四种不同的运算
思路：对一个函数设有三个变量，前两个变量是方法，最后一个设置为默认变量，变量是一共pow方法，即不传递参数时，进行幂运算
代码
python
#定义函数
def my_fun(a, b, fun=pow):
return fun(a, b)
print(my_fun(10, 20))
print(my_fun(10, 20, lambda a, b: a + b)) # 实现加法，将整个lambda穿个fun，再由fun对a,b进行计算
print(my_fun(10, 20, lambda a, b: a - b))
print(my_fun(10, 20, lambda a, b: a * b)
def my_fun(a, b, fun=pow):
return fun(a, b)
print(my_fun(10, 20))
print(my_fun(10, 20, lambda a, b: a + b)) # 实现加法，将整个lambda穿个fun，再由fun对a,b进行计算
print(my_fun(10, 20, lambda a, b: a - b))
print(my_fun(10, 20, lambda a, b: a * b)
###### 匿名函数之排序
对于不可更改的元素
可以用sorted方法进行排序
可以通过lambda设置按哪个关键字排序
对一个嵌套列表进行排序
`goods = [ # 商品名称 商品价格 商品的数量 ["电脑", 8848, 1000], ["电视", 6888, 500], ["手机", 12899, 100] ]`
排序后为：*[['手机', 12899, 100], ['电脑', 8848, 1000], ['电视', 6888, 500]]*
默认的排序会按首元素排序，可以通过指定元素排序（指定第二个排序）
```python
goods.sort(key=lambda x: x[1]) # 指定第二个元素
print(goods)
#[['电视', 6888, 500], ['电脑', 8848, 1000], ['手机', 12899, 100]]
面向对象
Python类库的使用
pip的使用
pip是管理python第三方资源库的文件，可用于下载，删除
再cmd窗口下输入“piP-V”,可查看当前pip版本
cmd中 输入 “pip list“可查看当前安装的包和版本
cmd 中 输入 "pip install '包名' ",进行下载
cmd 中 输入"pip uninstall '包名'"进行删除
安装指定版本的package,通过使用==, >=, <=, >, <来指定一个版本号。 pip install 'Markdown<2.0' pip install 'Markdown>2.0,<2.0.3
将已经安装好的库列表文件保存到文本文件中：pip freeze > requirements.txt
根据依赖文件批量安装package:pip install -r requirements.txt
prettytable
先导包中的类
from prettytable import PrettyTable 'as pt'(书写方便，创建别名)
将该类实例化
table = PrettyTable( )
即创建了该表，可以对表进行操作
Pandas
查询版本pandans.__version__
通过as设置别名import pandans as pd
pandas提供了一维和二维的数组
二维是多个一维数组通过共同索引连接
Pandas 数据结构-Series
pandas.Series( data, index, dtype, name, copy)
data：表示数据
index: 数据索引越界了
dtype: 数据类型
name:设置名称
copy:拷贝数据，默认false
通过列表创建对象，索引可设置也可以为默认
a=["Goggle","Runoob","Wiki"]
mywar=pd.Series(a)
print(mywa
#设置索引
mywar = pd.Series(a,['x','y','z'])
print(mywar)r)
用字典创建Series对象，key成了索引,values成了数据
如果只需要截取字典中的一部分，可以通过索引
dic = {1: 'a', 2: 'c', 3: 'd'}
myvar=pd.Series(dic,index=[2,3])
print(myvar)
# 2 c
# 3 d
# dtype: object
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8LsIacAE-1641173634665)(D:\Study\MarkText\Python\Images\2021-12-04-00-37-34-image.png)]
Pandas 数据结构—DataFrame
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZnXvVJ4P-1641173634666)(D:\Study\MarkText\Python\Images\2021-12-04-00-47-29-image.png)]
构造
data = [["Google", 5], ["Runoob", 6], ["Wiki", 4]]
df = pd.DataFrame(data, columns=['Site', 'Len'])
print(df)
Site Len
0 Google 5
1 Runoob 6
2 Wiki 4
DataFrame再创建是，values部分，[ [ a ] , [ b ] ],会将a列表当作一行添加
使用字典创建时，会自动把key当作列名
data = [{'a': 1, 'b': 2},{'a': 5, 'b': 10, 'c': 20}]
df = pd.DataFrame(data)
print (df)
a b c
0 1 2 NaN
1 5 10 20.0
添加行（loc[]方法）
当Dataframe是空的时候，进行赋值，通过循环
创建：df = pd.DataFrame(columns=['name','number'])
添加一行数据：df.loc[0]=['cat',10](df.loc[ ? ],中间需要的值为索引值也可以用‘a’替代)
可以通过loc属性返回指定行数据，其返回样式如下
Site Google
Len 5
Name: 0, dtype: object
其是返回的结果就是对应索引的每个Series的数据
添加行append（）方法
可以通过append合并两个DataFrame：df.append(df2,ignore_index=True)（设置为Ture可以重新排列索引）
通过append添加多行：
df = pd.DataFrame(columns=['A'])
for i in range(5):
df = df.append({'A': i}, ignore_index=True)
df
A
0 0
1 1
2 2
3 3
4 4
但遍历添加一般采用
pd.concat([pd.DataFrame([i],columns=['A']) for i in range(5)],ignore_index=True)
添加列df[ ]
添加列insert( )方法
# 使用方法是DataFrame.insert(loc, column, value, allow_duplicates=False)
# 即df.insert(添加列位置索引序号，添加列名，数值，是否允许列名重复)
df.insert(1, 'tail', 1, allow_duplicates=False)
df
name tail number leg head
0 cat 1 3 12 1
apply()函数和DataFrame的配合
#将函数应用到由各列或行形成的一维数组上。DataFrame的apply方法可以实现此功能
f=lambda x:x.max()-x.min()
#默认情况下会以列为单位，分别对列应用函数
t1=df.apply(f)
print(t1)
t2=df.apply(f,axis=1) # axis=1会改成对行操作
print(t2)
Pandas CSV文件
CSV介绍：CSV（Comma-Separated Values，逗号分隔值，有时也称为字符分隔值，因为分隔字符也可以不是逗号），其文件以纯文本形式存储表格数据（数字和文本）。
# CSV文件的操作
# 三个字段 name, site, age
nme = ["Google", "Runoob", "Taobao", "Wiki"]
st = ["www.google.com", "www.runoob.com", "www.taobao.com", "www.wikipedia.org"]
ag = [90, 40, 80, 98]
# 字典
dict = {'name': nme, 'site': st, 'age': ag}
df=pd.DataFrame(dict)
print(dict)
#保存为CSV
df.to_csv('thetest.csv')
#读取CSV
df = pd.read_csv("thetest.csv")
print(df)
print(df.to_string())
另外的head（[n]），tail( [n]),info()
对列应用函数
t1=df.apply(f)
print(t1)
t2=df.apply(f,axis=1) # axis=1会改成对行操作
print(t2)
###### Pandas CSV文件
**CSV介绍：CSV**（Comma-Separated Values，逗号分隔值，有时也称为字符分隔值，因为分隔字符也可以不是逗号），**其文件以纯文本形式存储表格数据（数字和文本）。**
```python
# CSV文件的操作
# 三个字段 name, site, age
nme = ["Google", "Runoob", "Taobao", "Wiki"]
st = ["www.google.com", "www.runoob.com", "www.taobao.com", "www.wikipedia.org"]
ag = [90, 40, 80, 98]
# 字典
dict = {'name': nme, 'site': st, 'age': ag}
df=pd.DataFrame(dict)
print(dict)
#保存为CSV
df.to_csv('thetest.csv')
#读取CSV
df = pd.read_csv("thetest.csv")
print(df)
print(df.to_string())
另外的head（[n]），tail( [n]),info()
13万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
