python中的小知识点

python中的小知识点

1.python中的main()方法

if __name__ == "__main__"

​ 事实上python程序是从上而下逐行运行的。在XX.py文件中，除了def后定义的函数外 的代码都会被认为是“main"方法的内容从上而下执行。

​ 要适应python没有main（）方法的特点。所谓的入口其实也就是个if条件语句，判断成功就执行一些代码，失败就跳过。没有java等其他语言中那样会有特定的内置函数去识别main()方法入口，在main()方法中从上而下执行。

2.python中self用法

3.iter(),next()

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6wg3wGFQ-1650033796754)()]返回迭代器的胸一个项目

• next()要和生成迭代器的 iter()函数一起使用

• next(iterable[, default])

  iterable – 可迭代对象

  default – 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。

• list、tuple等都是可迭代对象，我们可以通过iter()函数获取这些可迭代对象的迭代器。然后，我们可以对获取到的迭代器不断使⽤next()函数来获取下⼀条数据。

• iter()函数实际上就是调⽤了可迭代对象的 iter ⽅法。

• 当我们已经迭代完最后⼀个数据之后，再次调⽤next()函数会抛出 StopIteration的异常 ，来告诉我们所有数据都已迭代完成，不⽤再执⾏ next()函数了。

4.python enumerate用法总结

• enumerate是枚举的意思。

• 对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值

• enumerate多用于在for循环中得到计数

  #如果对一个列表，既要遍历索引又要遍历元素时，首先可以这样写：
  list1 = ["这", "是", "一个", "测试"]
  for i in range (len(list1)):
      print i ,list1[i]
  
   
  

#改进
list1 = ["这", "是", "一个", "测试"]
for index, item in enumerate(list1):
    print index,item
    #结果
   # 0 这
#1 是
#2 一个
#3 测试
    

#enumerate还可以接收第二个参数，用于指定索引起始值，
list1 = ["这", "是", "一个", "测试"]
for index, item in enumerate(list1, 1):
    print index, item
>>>
1 这
2 是
3 一个
4 测试

#如果要统计文件的行数，可以这样写：
count = len(open(filepath, 'r').readlines())

#改进
count = 0
for index, line in enumerate(open(filepath,'r')):
    count +=1

5.python中的下划线_

• python中的标识符命名规则和C/C++不一样，可以单个下划线_成为一个变量标识符。

_=1
_

• 一般看到别人的代码用这个来作为标识符，就表示这个是一个无关紧要的变量，但是又一定要有一个变量来承接。例如：

def hello():
    return 1,"hello,world"

_,s=hello()
s

6.eval(input()):

• input()返回用户输入的值，返回的总是字符串。
• eval() 的作用是将字符串的引号去掉，数字就是返回数字本身，表达式就返回结果。
• int()是将数字确定转换整数，也可将将包含整数的字符串转换为整数。
• eval(input):将输入的字符串的银行去掉。
• int(input()):将输入的字串转换为整数

7.保留小数的方法：

• round(a,2)

8. 多行数据输入 list（map(int,input().split()))

• input().split()用法：接收多个输入。返回的数据类型是str

year, month, day = map(int, input().split('/'))
#2018/2/1 
#如果是整数就需要转化为int才能正常使用。

• map()用法：map(function, iterable, …),python3 返回迭代器，要加list()函数转化为列表。

def f(x):
    return x*x
print(list(map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])))
#[1, 4, 9, 10, 25, 36, 49, 64, 81]

9.isinstance() 函数判断类型

• sinstance() 函数来判断一个对象是否是一个已知的类型，类似 type()。

  isinstance() 与 type() 区别：

  • type() 不会认为子类是一种父类类型，不考虑继承关系。
  • isinstance() 会认为子类是一种父类类型，考虑继承关系。
  • 如果要判断两个类型是否相同推荐使用 isinstance()。

>>>a = 2
>>> isinstance (a,int)
True
>>> isinstance (a,str)
False

10.列表解析式（x for x in list）

11.字符串的特殊字符

• 转义符\ 表达特定字符的本意

• 这里有个双引号（\*）"--这里有个双引号（*）
  

• \n换行

12.字符串处理方法

方法及使用	描述
str.join(iter)	在iter变量除了最后元素外每个元素后增加一个str “,”.join(“12345”)结果为"1,2,3,4,5"主要用于字符串分隔符
str.strip(chars)	“=python=”.strip(" =np") 结果为“ytho”

13.

1.条件

1.2if-elif-else

• 多分支条件之间的覆盖是重要问题
• 一定要检查分支结构
• 分支结构是程序的重要框架，读程序先看分支

2.循环结构

2.1 遍历循环

for <循环变量> in <遍历结构>:
    <语句块>
#从遍历结构中逐一提取元素，放在循环变量中
#完整遍历完所有元素后结束
#每次循环，所获得元素放入循环变量，并执行一次语句块

计数循环（N次）	for i in range(N): <语句块>
计数循环（N次）	for i in range(M,N,K):#M开始，N-1，K个步长 <语句块>
字符串遍历循环	for c in s: #s是字符串，遍历字符串每个字符，产生循环 <语句块>
列表遍历循环	for item in ls: #s是字符串，遍历字符串每个字符，产生循环 <语句块>
文件遍历循环	for line in fi: #fi 文件标识符 ， <语句块>

2.2无限循环

#由条件控制的循环运行方式
while <条件>：
	<语句块>
    #反复执行语句块，直到条件不满足时结束
	

2.4循环控制保留字

break#跳出并结束当前整个循环，执行循环后的语句
continue#结束当次循环，继续执行后续循环

#continue
for c in "PYTHON":
    if c=="T":
        continue
    print(c,end="")
    
>>PYHON

for c in "PYTHON":
    if c=="T":
        break
    print(c,end="")
    
>>PY

s = "PYTHON"
while s !="":
    for c in s:
        print(c,end="")
    s = s[:-1]#
>>pythonpythopythpytpyp

s = "PYTHON"
while s !="":
    for c in s:
        if c=="T":
            break #仅能跳出最内层循环
        print(c,end="")
    s = s[:-1]
>>PYPYPYPYPYP    

2.5循环的高级用法

#循环与else
for <循环变量> in <遍历结构>:
    <语句块1>
else:
    <语句块2>

#循环与else
for <条件>:
    <语句块1>
else:
    <语句块2>

• 当循环没有被break语句退出时，执行else语句块
• else语句块作为“正常”循环的奖励

for c in "PYTHON":
    if c=="T":
        continue
    print(c,end="")
else:
    print("正常退出")
>>PYTHON正常退出

for c in "PYTHON":
    if c=="T":
        break
    print(c,end="")
else:
    print("正常退出")
>>PY

3 random库基本介绍

import random

能够利用随机数种子产生"确定"伪随机数

能够产生随机整数

能够对序列类型进行随机操作

3.1基本随机数函数

函数	描述
seed(a=None)	初始化给定的随机数种子，默认为当前系统时间 >>>random.seed(10)#产生种子10对应的序列
random()	生成一个[0.0，1.0)之间的随机小数
randint(a,b)	生成一个[a,b]之间的整数
randint(m,n，[,k])	生成一个[m,n]之间以k为步长的随机整数
getrandbits(k)	生成一个k比特长的随机整数
uniform(a,b)	生成一个[a,b]之间的随机小数
choice(seq)	从序列seq中随机选择一个元素 random.choice([1.2.3.4.5.6.7.8.9]) >>>8
shuffle(seq)	将序列seq中元素随机排列，返回打乱后的序列 s=[1,2,3,4,5,6,7,8,9];random.shuffle(s);print(s) [3,5,8,9,1,2,7,4]

14.函数

1.1函数的理解和定义

• 函数是一段代码表示。
• 降低编程难度和代码复用。

def <函数名>(<参数(0个或多个)>):
    <函数体>
    return <返回值>

• 调用是运行函数代码的方式。
  • 调用时要给出实际参数
  • 实际参数替换定义中的参数
  • 函数调用后得到返回值

def fact(n):
    s = 1
    for i in range(1, n + 1):
        s *= i
    return s


print(fact(10))

• 可选参数

def <函数名>(<非可选参数>,<可选参数>):
    <函数体>
    return <返回值>

• 可变参数

def <函数名>(<参数>,*b):
    <函数体>
    return <返回值>

• 函数的参数传递

#函数调用时，参数可以按照位置或名称方式传递
- 位置传递
- 名称传递

• 函数返回值

#函数可以返回0个或多个结果
#函数可以有返回值也可以没有

• 局部变量–函数

  • 局部变量是函数内部占位符，与全局变量重名但不同。函数运算结束后，局部变量被释放

  • n, s = 10, 100
    
    
    def fact(n):
        s = 1
        for i in range(1, n + 1):
            s *= i
        return s#函数运行完就释放掉了
    
    
    print(fact(n), s)
    >>> 3628800 100
    

  • 使用global保留字在函数内部使用全局变量

  • 局部变量为组合数据类型且未创建，等同于全局变量

  • ls = ["F", "f"]
    
    def func(a):
        ls.append(a)
        return
    
    func("C")
    print(ls)
    >>>['F', 'f', 'C']
    

• 全局变量–程序

• lambda函数

  • lambda函数返回函数名作为结果
  • lambda函数是一种匿名函数，即没有名字的函数
  • lambda函数用于定义简单的，能够在一行内表示的函数

<函数名> = lambda <参数>:<表达式>
等价于：
def <函数名>(<参数(0个或多个)>):
    <函数体>
    return <返回值>

f = lambda x, y: x + y
print(f(10, 15))

f = lambda: "lambda函数"
print(f())

• 理解方法思维：
  • 模块化思维：确定模块接口，封装功能
  • 规则化思维：抽象过程为规则，计算机自动执行

1.2代码复用与函数递归

• 代码复用

函数：将代码命名 在代码层面建立了初步抽象	对象：属性和方法 .和.() 在函数之上再次组织进行抽象

• 模块化设计：通过函数或对象封装将程序划分为模块及模块间的表达。

  • 紧耦合
  • 松耦合

• 函数递归

  • 函数定义中调用函数自身的方式
  • 两个关键特征
    • 链条：计算过程存在递归链条
    • 基例：存在一个或多个不需要再次递归的基例

def fact(n):
    if n == 0:
        return 1
    else:
        return n * fact(n - 1)

print(fact(10))

• 递归的实现（函数+分支语句）
  • 递归本身就是一个函数，需要函数定义方式描述
  • 函数内部，采用分支语句对输入参数进行判断
  • 基例和链条，分贝编写对应代码

#字符串反转
def rvs(s):
    if s == "":
        return s
    else:
        return rvs(s[1:]) + s[0]

print(rvs("python123"))

#费波纳契数列
def f(n):
    if n == 1 or n == 2:
        return 1
    else:
        return f(n - 1) + f(n - 2)

print(f(5))
f(4)+          f(3)
f(3)+f(2)      f(2)+(1)
f(2)+f(1)+f(2)

import turtle

def koch(size, n):
    if n == 0:
        turtle.fd(size)
    else:
        for angle in [0, 60, -120, 60]:
            turtle.left(angle)
            koch(size / 3, n - 1)

def main():
    turtle.setup(600, 600)
    turtle.penup()
    turtle.goto(-200, 100)
    turtle.pendown()
    turtle.pensize(2)
    level = 3  # 3阶科赫雪花，阶数
    koch(400, level)
    turtle.right(120)
    koch(400, level)
    turtle.right(120)
    koch(400, level)
    turtle.hideturtle()

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YHK1PHa4-1650033796755)(C:\Users\31898\AppData\Roaming\Typora\typora-user-images\image-20220323142648092.png)]

15.组合数据类型

1.集合类型及操作

• 集合是多个元素的无序组合

• 每个元素唯一，不存在相同元素

• 集合元素是不可更改，不能是可变数据类型

• {}表示，元素间用逗号分隔，建立空集合类型，必须使用set()(一个一个分开)

1.1集合操作符

S|T	并
S-T	差
S&T	交
S^T	补
S <=T或S<T	返回True/False,判断S和T的子集关系
S >=T或S>T	返回True/False,判断S和T的包含关系

1.2集合的处理方法

操作函数或方法	描述
S.add(x)	x添加到S中
S.discard(x)	移除S中元素x，如果x不在集合S中，不报错
S.remove(x)	移除S中元素x，如果x不在集合S中，产生KeyError异常
S.clear()	移除S中所有元素
S.pop()	随机返回S的一个元素，更新S，若S为空产生KeyError异常
S.copy()	返回集合S的一个副本
len(S)	S的元素个数
x in S	判断S中元素x，x在集合S中，返回True，否则返回False。
x not in S	判断S中元素x，x不在集合S中，返回True，否则返回False。
set(x)	将其他类型变量x转变为集合类型

#集合处理方法
A = {"p", "y", 123}
for item in A:
    print(item, end="")

#######
try:
    while True:
        print(A.pop(), end="")
except:
    pass

1.3 集合类型及操作

• 关系比较

"p" in {"p","y",123}
>>>True
{"p","y"} >={"p","y",123}
>>>False

• 数据去重：集合类型所有元素无重复

ls = ["p","p","y","y",123]
S = set(ls)
>>>{'p','y','123'}
lt = list(s)
['p','y',123]

2.序列类型及操作

• 序列是具有先后关系的一组元素
• 一维元素向量，元素类型可以不同
• 元素间由序号引导，通过下标访问序列的特定元素
• 序列是一个基类类型
  • 字符串类型
  • 元组类型
  • 列表类型

2.1序列处理函数及方法

操作函数或方法	描述
x in S	如果x是序列s的元素，返回True，否则返回False。
x not in S	如果x不是序列s的元素，返回True，否则返回False。
s+t	连接两个序列s和t
sn或者ns	将序列s复制n次
s[i]	索引，返回s中第i个元素，i是序列的序号
s[i:j]或s[i:j:k]	切片，返回序列s中第i到j以k为步长的元素子序列
len(s)	返回序列s的长度
min(s)	返回序列s的最小元素，s中元素需要可比较
max(s)	返回序列s的最大元素，s中元素需要可比较
s,index(x)或 s.index(x,i,j)	返回序列s从i开始到j位置中第一次出现元素x的位置
s.count(x)	返回序列s中出现x的总次数

#序列类型操作实例
ls = ["python", 123, ".io"]
print(ls[::-1])

s = "python123.io"
print(s[::-1])

2.2元组类型及操作

• 元组是序列类型的一种扩展，一旦创建就不能被修改
• 使用**()或者tuple()**创建，元素间用逗号","
• 可以使用或不适用小括号

def func():
    return 1,2

#元组类型定义
creature = 'cat','dog'.'tiger','human'
creature
>>>('cat','dog'.'tiger','human')
color = (0x001100,"blue",creature)
color 
>>>(4352,'blue',('cat','dog','tiger','human'))

• 元组继承序列类型的全部通用操作
• 元组因为创建后不能修改，因为没有特殊操作

creature = 'cat','dog','tiger','human'
creature[::-1]
>>>(,'dog',,'human','tiger','dog','cat')
color = (0x001100,"blue",creature)
color[-1][2] 
>>>'tiger'

2.3 列表类型定义

• 列表是序列类型的一种拓展，创建后可以随意被修改
• 使用**[]或list()**创建，元素之间用逗号，
• 列表中各元素类型可以不同，无长度限制

ls = ["cat","dog","tiger",1024]
ls
>>>['cat','dog','tiger',1024]
lt = ls
>>>['cat','dog','tiger',1024]
#方括号[]真正创建一个列表，赋值仅传递引用
#lt和ls指向同一个列表，同一个空间。

操作函数或方法	描述
ls[i] = x	替换列表ls第i元素为x
ls[i:j:k] = lt	用列表lt替换ls切片后所对应元素子列表
del ls[i]	删除列表ls中第i元素
del ls[i:j:k]	删除列表ls中第i到第j以k为步长的元素
ls +=lt	更新列表ls，将列表lt元素增加到列表ls中
ls* = n	更新列表ls，其元素重复n次
ls.append(x)	在列表ls最后增加一个元素x
ls.clear()	删除列表ls中所愿元素
ls.copy	生成一个新列表，赋值ls中所有元素
ls.insert(i,x)	在列表ls的第i位置增加元素x
ls.pop(i)	将列表ls中第i位置元素取出并删除该元素
ls.remove(x)	将列表ls中出现的第一个元素x删除
ls.reverse()	将列表ls中的元素反转。

ls = ["cat", "dog", "tiger", 1024]
ls[1:2] = [1, 2, 3, 4]
print(ls[1:2])

del ls[::3]
print(ls)

ls * 2
print(ls)


>>>[1]
>>>[1, 2, 4, 'tiger']
>>>[1, 2, 4, 'tiger']

ls = ["cat", "dog", "tiger", 1024]
ls.append(1234)
print(ls[1:2])

ls.insert(3, "human")
print(ls)

ls.reverse()
print(ls)
>>>['dog']
['cat', 'dog', 'tiger', 'human', 1024, 1234]
[1234, 1024, 'human', 'tiger', 'dog', 'cat']

2.4序列类型应用场景

• 元组用于元素不改变的应用场景，更多用于固定搭配场景

• 列表更加灵活

• 最主要作用：表示一组有序数据，进而操作他们。

• 元素遍历

for item in ls:
    <语句块>
for item in tp:
    <语句块>
    

• 数据保护-如果不希望数据被程序所改变，转换成元组类型。

ls = ["cat", "dog", "tiger", 1024]
lt = tuple(ls)
print(lt)

3.基本统计值计算问题分析

• 总个数：len()
• 求和：for … in
• 平均值：求和/总个数
• 方差：各数据于平均数差的平方的和的平均数
• 中位数：排序，然后。。。奇数找中间1个，偶数找中间2个取平均

4.字典类型及操作

• 映射：是一种键(索引)和值(数据)的对应。
• 键值对：键是数据索引的拓展
• 字典是键值对的集合，键值对之间无序
• **{}和dict(),**剪纸对用冒号：表示
• {<键1>:<值1>，<键2>:<值2>.。。。}
• 在字典变量中，通过键获得值

<字典变量> = {<键1>:<值1>,...<键n>:<值n>}
<值> = <字典变量>[<键>]
<字典变量>[<键>]= <值>  

操作函数或方法	描述
del d[k]	删除字典d中键k对应的数据值
k in d	判断键k 是否在字典d中，如果返回True，否则False
d.keys()	返回字典d中所有的键信息
d.values()	返回字典d中所有值的信息
d.get(k,)	如果k存在，则返回相应值，不在则返回值
d.pop(k,)	如果k存在，则取出相应值，不在则返回值
d.popitem()	随机从字典d中取出一个简直对，以元组形式返回
d.clear()	删除所有键值对
len(d)	返回字典d中元素的个数

4.1字典类型应用场景

• 映射无处不在，键值对无处不在
• 主要作用：表达键值对数据，进而操作他们
• 元素遍历

for k in d:
    <语句块>

5.1jieba库基本介绍

• jieba是优秀的中文分词第三方库
• jieba库提供三种分词模式， 掌握一个函数
• jieba分词依靠中文词库
• 除了分词，用户还可以添加自定义词组。

操作函数或方法	描述
精确模式	精确切分，不存在冗余单词
全模式	所有可能的词语都扫描出来，有冗余
搜索引擎模式	在精确模式基础上，对长词再次切分

操作函数或方法	描述
jieba.lcuts()	精确模式,返回一个列表类型的分词结果
jieba.lcuts(s,cut_all=True)	全模式,返回一个列表类型的分词结果，存在冗余
jieba.lcut_for_sear(ch(s))	搜索引擎模式,返回一个列表类型的分词结果，存在冗余
jieba.add_word(w)	向分词词典增加新词w

5.2文本词频统计

import jieba
excludes = {"将军", "却说", "荆州", "二人", "不可", "不能", "如此"}
txt = open("threekingdoms.txt", "r", encoding='utf-8').read()
words = jieba.lcut(txt)
counts = {}
for word in words:
    if len(word) == 1:
        continue
    elif word == "诸葛亮" or word == "孔明曰":
        rword = "孔明"
    elif word == "关公" or word == "云长":
        rword = "关羽"
    elif word == "玄德" or word == "玄德曰":
        rword = "刘备"
    elif word == "孟德" or word == "丞相":
        rword = "曹操"
    else:
        rword = word
    counts[rword] = counts.get(rword, 0) + 1
for word in excludes:
    del counts[word]dewor
items = list(counts.items())
items.sort(key=lambda x: x[1], reverse=True)#隐函数，x: x[1]是对前面的对象中的第二维数据的值进行排序。
for i in range(10):
    word, count = items[i]
    print("{0:<10}{1:>5}".format(word, count))

16.文件和数据格式化

6.1文件的使用

• 文件处理的步骤：打开-操作-关闭
• 文件的使用

<变量名> = open(<文件名>, <打开模式>)
          文件路径和名称   文本/二进制
                         读or写

• 文件的打开

文件的打开模式	描述
‘r’	只读，如果不存在，返回FileNotFoundError
‘w’	覆盖写，文件不存在则创建，存在则完全覆盖
‘x’	创建写，文件不存在则创建，存在则返回FileExistsError
‘a’	追加写模式，文件不存在则创建，存在则在文件最后追加内容
‘b’	二进制文件模式
‘t’	文本文件模式，默认值
‘+’	与r/w/x/a一同使用，在原功能基础上增加同时读写功能

• 文件的关闭

<变量名> .close()

6.2文件内容的读取

操作方法	描述
.read(size = -1)	读入全部内容，如果给出参数，读入前size长度 >>>s = f.read(2)
.readline(size = -1)	读入一行内容，如果给出参数，读入该行前size长度 >>>s = f.readline()
.readlines(hint = -1)	读入文件所有行，以每行元素形成列表。如果给出参数，读入前hint行 s = f.readlines()

• 文件的全文本操作
  • 遍历全文本

#方法1 统一输入，一次处理
fname = input("请输入要打开的文件名称：")
fo = open(fname,"r")
txt = fo.read()
fo.close()
#方法2 按数量读入，逐步处理
fnme = input("请输入要打开的文件名称")
fo = open(fname,"r")
txt = fo.read(2)
while txt !=""
	#对txt进行处理
    txt = fo.read(2)
fo.close()

• 文件的逐行操作

#逐行遍历文件：方法一
fname = input("请输入要打开的文件名称：")
fo  = open(fname,'r')
for line in fo.readlines()#一次读入，分行处理
	print(line)
fo.close()
#逐行遍历文件：方法二
fname = input("请输入要打开的文件名称：")
fo  = open(fname,'r')
for line in fo#分行读入，逐行处理
	print(line)
fo.close()

6.3 数据的文件写入

操作方法	描述
.write(s)	向文件写入一个字符串或字节流 >>>f.write("中国是一个伟大的国家！ ")
.writelines(lines)	将一个元素全为字符串的列表写入文件。 >>>ls = [“中国”，“法国”，“美国”] >>>f.write（ls) 中国法国美国
.seek(offset)	改变当前文件操作指针的位置，offset的含义如下： 0-文件开头，1-当前位置，2-文件结尾 >>>f.seek(0)#回到文件开头

#数据的文件
fo = open("output.txt","w+")
ls = ["中国"，"法国"，"美国"]
fo.writelines(ls)
fo.seek(0)
for line in fo:#写入一个字符串列表
   print(line)
fo.close()
>>>中国法国美国

6.4

• 理解方法思维

• 自动化思维：数据和功能分离，数据驱动的自动运行

• 接口化设计：格式化设计接口，清晰明了

• 二维数据应用：应用维度组织数据，二维数据最常用

• 应用问题的扩展

• 扩展接口设计，增加更多控制接口

• 扩展功能设计，增加弧形等更多功能

• 扩展应用需求，发展自动轨迹绘制到动画绘制

17.一维数据的格式化和处理

• 一维：由对等关系的有序或无序数据构成，采用线性方式组织（列表和集合类型）
• 二维：由多个一维数据构成，是一维数字的组合形式（列表类型）
• 高维：由一维或二维数据在新维度上拓展形成的。
  • 仅利用最基本的二元关系展示数据间的复杂结构 - 键值对

1.一维数据的表示

应用场景	方法	列子
如果数据间有序：	使用列表类型;使用for循环可以遍历数据，对每个数据进行处理	ls = [3.1398,3.1349,3.1376]
如果数据间无序：	使用集合类型;使用for循环可以遍历数据，对每个数据进行处理	ls = {3.1398,3.1349,3.1376}

2.一维数据的存储

	方法	列子
空格分隔	使用一个或多个控股封进行存储，不换行。 缺点：数据中不能存在空格。
逗号分隔	使用英文半角逗号分隔数据进行存储，不换行。 缺点：数据中不能有英文逗号。
其他方式	使用其他符号或符号组合分隔，建议采用特殊符号。 缺点：需要根据数据特点定义，通用性较差。

3.一维数据的处理

• 从空格分隔的文件中读入数据

#中国 美国 日本 德国 法国
txt = open(fname).read()
ls =txt.split()
f.close()
>>>ls
['中国','美国','日本','德国','法国']

• 从特殊符号分隔的文件中读书数据

#中国$美国$日本$德国$法国
txt = open(fname).read()
ls =txt.split()
f.close()
>>>ls
['中国','美国','日本','德国','法国']

• 采用空格分隔方式将数据写入文件

ls = ['中国','美国','日本']
f = open(fname,'w')
f.write(''.join(ls))
f.close()

• 采用空格分隔方式将数据写入文件

ls = ['中国','美国','日本']
f = open(fname,'w')
f.write('$'.join(ls))
f.close()

4.二维数据

• 列表类型。[[3.1,3.2,3.2],[3.4,4.6,7,8]]。使用两层for循环遍历每个元素
• 二维数据的格式化和处理
• csv与二维数据的存储

#索引习惯：ls[row][coliumn]先行后列

• 二维数据处理

fo = open(fname)
ls = []
for line in fo:
    line = line.replace("\n","")
    ls.append(line.split(","))
fo.close()

ls = [[1, 2], [3, 4], [5, 6]]  # 二维列表
for row in ls:
    for column in row:
        print(column)
1
2
3
4
5
6

• 二维数据的处理：for循环+.split()和.join()

5.wordcloud库的使用

• w = wordcloud.WordCloud()

方法	描述
w.generate(txt)	向wordcloud对象中加载文txt
w.to_file(filename)	将词云输出为图像文件，.png w.to_file(“outfile.png”)

• wordcloud库常规方法
  • 1.配置对象参数
  • 加载词云文件
  • 输出词云文件

import wordcloud
c = wordcloud.WordCloud()
c.generate("wordcloud by Python")
c.to_file("pywordcloud.png")

• 分隔：以空格分隔单词
• 统计：单词出现次数并过滤
• 字体：根据统计配置字号
• 布局：颜色环境尺寸

配置参数

• width
• height
• min_font_size
• max_font_size
• font_step
• font_path 字体路径
• max_words
• stop_words
• mask
• background_color

import jieba
import wordcloud

txt = "程序设计语言是计算机能够理解和\
识别用户操作意图的一种交互体系，它按照\
特定规则组织计算机指令，使计算机能够自\
动进行各种运算处理。"

w = wordcloud.WordCloud(width=800, font_path="msyh.ttc", height=600)
w.generate(" ".join(jieba.lcut(txt)))
w.to_file("pywcloud.png")

import jieba
import wordcloud
f = open("新时代中国特色社会主义.txt","r",encoding ="utf-8")
t = f.read()
f.close()
ls = jieba.lcut(t)
txt = " ".join(ls)
w =wordcloud.WordCloud(font_path="msyh.ttc",\
width = 1000, height = 700, background_color="white")
w.generate(txt)
w.to_file("w.png")

列表推导式

yield

• yield 的作用就是把一个函数变成一个 generator，带有 yield 的函数不再是一个普通函数，Python 解释器会将其视为一个 generator.调用 fab (5) 不会执行 fab 函数，而是返回一个 iterable 对象！. 在 for 循环执行时，每次循环都会执行 fab 函数内部的代码，执行到 yield b 时，fab 函数就返回一个迭代值，下次迭代时，代码从 yield b 的下一条语句继续执行，而函数的本地变量看起来和上次中断执行前是完全一样的，于是函数继续执行，直到再次遇到 yield。.

删除重复值

• drop_duplicates 方法实现对数据框 DataFrame 去除特定列的重复行，返回 DataFrame 格式数据。

DataFrame.drop_duplicates(subset=None, keep='first', inplace=False, ignore_index=False)

参数：

• subset – 指定特定的列 默认所有列
• keep:{‘first’, ‘last’, False} – 删除重复项并保留第一次出现的项 默认第一个
  keep=False – 表示删除所有重复项 不保留
• inplace – 是否直接修改原对象
• ignore_index=True – 重置索引 （version 1.0.0 才有这个参数）
• 例子：

# 单列
df.drop_duplicates('b', 'first', inplace=True)
# 多列
df.drop_duplicates(subset=['a', 'b'], keep='first', inplace=False)
# 删除所有重复项 不保留
df.drop_duplicates(subset=['a', 'b'], False)
# 默认按所有列去重

df.drop_duplicates()
# 指定列
df.drop_duplicates(subset=['brand'])
# 保留最后一个重复值
df.drop_duplicates(subset=['brand', 'style'], keep='last')

• 删除重复项后重置索引

# 方法一
df.drop_duplicates(ignore_index=True)

# 方法二
df.drop_duplicates().reset_index(drop=True)

# 方法三
df.index = range(df.shape[0])

Xpath 和lxml.html

方法

• lxml.html.fromstring()这个方法会把从requests库获取的HTML文本转换成可以分析 的HTML对象。

• HTML对象可以当作我们用谷歌浏览器的开发者工具来分析的网页，可以通过鼠标来定位元素。

• Xpath的方法就是可以用来定位元素。

  表达式	功能
  /	选择元素，但必须从HTML的根目录中选择。如/html/body/div会选择HTML 元素下面的body元素，body元素下面的所有div元素。
  //	选择所有元素，不管元素在HTML中的位置。如//div会选择HTML中所有的div元素。
  .	选择当前元素。如.//li，会选择当前元素下面的所有的li元素
  @	选择HTML元素的属性。如//li[@cliass]选择的式所有带有class属性的li元素。 //li[@class=“fruit”]会选择所有clss=“fruit”的li元素。 //div[@attr1=“a”][@attr2=“b”]选择带有attr1=a和atrr2=b的属性的元素
  //element[n]	选择所有element元素的第n个元素
  //*[@attr=“abc”]	选择所有带attr=“a”属性的任何元素。正则表达式

正则表达式

相关知识点

• 正则表达式是由一系列字符组成的一种搜索模式。这种模式通常用来进行文字的匹配，查找和替换。

  • 匹配的目的是用来验证（字符串）是否和正则表达式一致。
  • 查找用于搜索文本中和正则表达式匹配的一些字符串（部分字符串）
  • 替换则是将文本中找到匹配的字符串进行替换。

• 转义通常用来表示特殊意义的字符。

  • \n 表示换行
  • \t = Tab
  • 转义可以用来消除字符本身具有的特殊意义 .= .

常用元字符

• 元字符	功能
  .	匹配除换行符之外的任意字符
  []	匹配在[]中的单个字符。
  [^]	匹配不在[]中的单个字符。与上面功能相反。
  ()	将()中的正则表达式匹配的内容进行标记，可以使用\number形式。
  +	使+前面正则表达式出现1次或多次。
  ？	使？前面正则表达式出现0次或1次。
  *	使*前面的正则表达式出现0次或多次。
  *？，+？，？？	懒惰，模式。默许上面的+，？和*，会尽可能多地匹配（比较贪婪），但如果在它们后面加上？，则它们就会变得懒惰。
  {M,N}	使{M，N}之前的正则表达式出现M到N次。 eg.a{1,3}b,匹配ab，aab，aaab。 a{,3}b匹配b，ab，aab，aaab a{1,}b,匹配ab，以及1个以上的a和最后跟一个b。
  |	匹配|两边的任意一个正则表达式。如[a-z]+|[0-9]+可以匹配字符串abc，也可以匹配123.
  \w	匹配组成语言的字符，等价于[a-zA-z0-9],当然也包含中文。
  \W	与\w的作用相反，匹配非组成语言的字符，如\W+可以匹配#?!字符串
  \s	匹配普通空格、制表符，换行符等字符
  \S	与\s的作用相反，如\S+可以匹配字符串abc中的ab
  \d	匹配任意字符数字，包含中文输入状态下的数字123（注意中英文状态下的123不同）
  \D	与\d的作用相反，匹配除数字之外的字符，如\D+可以匹配a-b-c!!!字符串
  ^	匹配字符串开头，可以和re.MULTILNE标志相结合使用
  $	匹配字符串结尾，可以和re.MULTILNE标志相结合使用

re库方法

表达式	功能
re.match()	# match(正则表达式，目标字符串)，如果匹配返回一个匹配对象，反之 None。 # 从第一个字符开始从左到右进行匹配，直到把所有的正则表达式全部匹配完成。如果匹配成功返回一个匹配对象，反之 None。
re.search()	从目标字符串的第一个字符开始搜索，从目标字符串中搜索能够匹配的字符串
re.sub()	re.sub(正则表达式，用来进行替换的字符串，目标字符串)
re.findall()	#re.findall(正则表达式，目标字符串)，返回的是一个包含所有匹配字符串的列表。 #re.findall()方法通常用于在文本里搜索特定的字符串
//element[n]	选择所有element元素的第n个元素
//*[@attr=“abc”]	选择所有带attr=“a”属性的任何元素。正则表达式

python中的for循环

1.执行迭代

• for
• while
• break
• continue

2.详解for循环

• 1.在python中，for循环用于遍历一个迭代对象的所有元素。循环内的语句段会针对迭代对象的每一个项目都执行一次。

for 变量 in iterable（迭代对象）

• 2.可迭代对象与迭代器

  (1)Python 中，一个 iterable 对象指在 for 循环中可以被迭代的任意对象。就是当这个对象作为参数传递给 iter()方法时应该返回一个迭代器。

  iter("you are awesome!")#字符串
  #<str_iterator at 0x22d19543cc0>
  iter(["you","are","awesome!"])#列表
  #<list_iterator at 0x22d5196a668>
  iter(("you","are","awesome!"))#元组
  #<tuple_iterator at 0x22d5196af98>
  iter({"you","are","awesome!"})#集合
  #<set_iterator at 0x22d59996288>
  iter({1:"you",2:"are",3:"awesome!"})#字典
  #<dict_keyiterator at 0x22d59990908>
  iter(range(3))#range函数
  #<range_iterator at 0x22d51969690>
  

  对iterable对象调用iter()时，它会返回一个迭代器对象。

  (2)迭代器在python中被定义为一个表现为流式数据的对象。基本上，如果我们将对象传递给内置的next() 方法，它应该从与之关联的流式数据中返回下一个值。一旦所有的元素都遍历结束，它会抛出一个StopIteration 异常。*next()*方法的后续调用也都会抛出StopIteration 异常。

  在对迭代对象调用iter()每次都会返回不同的迭代器，但是在迭代器上调用iter()返回的是同一个迭代器。

  (3)迭代器协议

  1. 一个可迭代对象，作为参数传递给 iter() 方法时返回一个迭代器。

  2. 一个迭代器，

  3. 作为参数传递给next()方法时返回它的下一个元素或者在所有元素都遍历结束时抛 出StopIteration 异常。

  4. 作为参数传递给iter() 方法时返回它自身。

  迭代协议仅仅只是一种将对象定义为迭代器的标准方式。我们已经在前一节看到了这种协议的实际应用。根据协议，迭代器应该定义以下两个方法：

  1. next()

     1. 每次调用这个方法时，应该返回迭代器的下一个元素。一旦元素都遍历结束，它应该抛出StopIteration 异常。

  2. 当我们调动内置函数next() 时，实际内部调用的是本方法。

  3. iter()

     1. 这个方法返回迭代器自身

  4. 当我们调动内置函数iter() 时，实际内部调用的是本方法。

  3.for循环工作原理

  1.在for语句中对被迭代对象调用了iter()方法，返回结果是一个迭代器。

  2.接着对迭代器调用next()方法，并将返回值赋给变量。

  3.for循环中关联的语句打印。

python的列表，字典，元组，集合的特点和区别

1.list，tuple，set，dict的区别

	列表	元组	集合	字典
英文	list	tuple	set	dict
可否读写	读写	只读	读写	读写
可否重复	是	是	否	是
存储方式	值	值	键(不能重复)	键值对(键不能重复)
是否有序	有序	有序	无序	无序
初始化	[1,‘a’]	(‘a’,1)	set([1,‘a’]) 或{1,2}	{‘a’:1,‘b’:2}
添加	append	只读	add	d[‘key’] = ‘value’
读元素	res[2:]	t[0]	无	d[‘a’]

2.概念，使用场景，特点

	列表	元组	集合	字典
概念	列表是 一个用list类定义的序列，包括创建、操作和处理列表的方法。列表中元素可以通过下标来访问。	元组和列表类似，但元组中元素固定不变， 一旦一个元组被创建后，无法对该元组进行添加、删除、替换和重新排序的操作。	集合与列表类似，可以使用他们存储一个元素集合。但是与列表不同，集合中的元素时不重复并且不是按照特定顺序放置的。	字典是一个存储键值对集合的容器对象，它通过使用关键字实现快速获取、删除和更新值。
使用场景	程序需要存储大量的数据，我们需要有一个高效、条理的方式。列表数据类型能存储一个有序的元素集合。存储的数据可以通过列表变量来访问。	当应用中存在不应该对列表数据进行修改的情况时，为了防止数据被恶意修改我们应当使用元组类型来存储数据，防止数据被恶意的添加、删除、替换，并且元组比列表的效率更高。	当应用程序不需要在意元素的顺序，使用一个集合来存储元素比列表效率会更高。	字典能够通过键值对的形式精确查找数据，并且支持数据异构
特点	（1）在其他程序设计语言中使用来存储数据序列的数组数据类型大小是固定的，python中列表的大小时可变的可以按照需求增加、减小。 （2）一个列表可以包含同类型元素也可以包含不同类型的元素。 （3）python中字符串和列表都是序列类型。一个字符串是一个字符序列，一个列表是任何元素序列。	（1）元组中数据固定不可添加、修改、替换、重新排序。 （2）元组是序列，针对序列的常见操作可以应用于元组。比如可以使用len、min、max、sum函数。 （3）可以使用for循环遍历元组中元素，使用下标运算符访问元组中对应的有元素和元素段，可以使用IN和NOT IN运算判断一个元素是否在元组中。 （4）一个元组包含着是一个固定的元素列表。一个元组里的每个个体的元素可能是可变的。	（1）可以通过将元素用花括号{}括起来创建一个元素集合，集合中元素用逗号分隔。 （2）每一个集合可以包含类型相同和不同的元素。 （3）集合中每个对象必须是哈希的（python中每个对象有一个哈希值如果在对象的生命周期中对象的哈希值没有改变那么这个对象是哈希的）	（1）能通过关键字快速获取、删除和更新值。 （2）字典可以包含类型相同和不同的元素。 （3）字典数据与数据顺序无关。