python中有哪些可以生成汉字的三方库

目录 

1、数据类型和变量

2、字符串和编码

3、使用list和tuple

4、条件判断

5、循环

6、字典（dict）和集合（set）

1、数据类型和变量

整数：

浮点数：小数 。可以用数学写法如:1.33，也可以用科学计数法如：1.23e-5。 

整数和浮点数在计算机内部的存储方式是不同的，整数运算永远是精确的（包括除法），而浮点数运算可能会有四舍五入的误差。

字符串：以单引号 ' 或双引号 " 括起来的任意文本。

转义字符 \：

\n：换行

\t：制表

\\：\

r' '：表示' '内的字符串默认不转义

''' ...''' ：表示换行，可以有很多换行，如：

print（'''line1
line2
line3'''）

输出为：

line1
line2
line3

布尔值：ture false

布尔值可以用and、or、not来计算。

空值：None，

变量：大小写英文、数字和 _ 的组合，不能用数字开头。

注意：变量本身类型不固定的语言称为动态语言，与之对应的是静态语言（Java为静态语言：比如不能把字符串赋给整数型变量）

常量

2、字符串和编码

字符编码：

字符	ASCII	Unicode	UTF-8
A	01000001	00000000 01000001	01000001
中	x	01001110  00101101	11100100 10111000 10101101

 ASCII 编码：一个字节表示1个字符。

Unicode 编码：两个字节表示一个字符（特别偏僻的字符用4个字节）。支持多语言。

问题是：若写的文本全是英文，用Unicode编码比ASCII编码需要多一倍的存储空间，在存储和传输上就十分不划算，所以有了UTF-8编码。

UTF-8编码：可变长编码。1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个。只有很生僻的字符才是4-6个字节。

计算机系统通用的字符编码工作方式：

在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者需要传输的时候，就转换为UTF-8编码。

Python字符串

在python3中，字符串以Unicode编码

对于单个字符编码：

ord( ) ：获取字符的整数表示        例：>>>ord('A')    输出：65

chr( )：把整数编码转换为对应的字符     例：>>>chr(25991)    输出：文

python的字符串类型是 str ，在内存中以Unicode表示。若要在网络上传输，或者保存到磁盘上，需要把 str 变为以字节为单位的 bytes。

x  =  b'ABC'

以Unicode表示的 str 可以用 encode( ) 方法编码为指定的 bytes ，例：

>>> 'ABC'.encode('ascii')
b'ABC'
>>> '中文'.encode('utf-8') #含有中文的 str 无法用ASCII编码
b'\xe4\xb8\xad\xe6\x96\x87'

如果我们从网络或磁盘上读取了字节流，那么读到的数据就是 bytes。要把 bytes变为 str，就需要用decode( ) 

>>> b'ABC'.decode('ascii')
'ABC'
>>> b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
'中文'

如果bytes中只有一小部分无效的字节，可以传入errors='ignore'忽略错误的字节：

>>> b'\xe4\xb8\xad\xff'.decode('utf-8', errors='ignore')
'中'

 len( )计算字节 ，还可以计算列表中的元素

>>>len('ABC')          输出 ： 3           计算 str 包含多少个字符
>>>len('中文'.encode('utf-8'))       输出：6  计算 bytes  中文的字符数

 当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

格式化

例：>>>'Hello,%s' %'world'  输出：'Hello,world'

常见的占位符

占位符	替换内容
%d	整数
%f	浮点数
%s	字符串
%x	十六进制整数

其中，%d和%f 可以指定是否补0和整数与小数的位数；

print('%2d-%02d'  % (3,1))      输出：3-01
print('%.2f'  %  3.1515926)      输出：3-14

用%%来表示字符%

format( )  会用传入的参数依次替换字符串内的占位符{0}、{1}，比%要麻烦。

>>> 'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125)
'Hello, 小明, 成绩提升了 17.1%'

3、使用list和tuple

列表 list 和元组 tuple 都是一个可以放置任意数据类型的有序集合

l = [1, 2, 'hello', 'world'] # 列表中同时含有 int 和 string 类型的元素
tup = ('jason', 22) # 元组中同时含有 int 和 string 类型的元素

• 列表[ ]是动态的，长度大小不固定，可以任意的增加、删减或者改变元素（mutable），存储空间略大于元组，性能略逊于元组。
• 元组( )是静态的，长度大小固定，无法增加、删减或者改变（immutable），元组相当于列表更加轻量级，性能稍优。 

索引是从0开始，最后一个为len(list())-1，还可以用-1来表示最后一个元素。-2，-3...

>>> classmates = ['Michael', 'Bob', 'Tracy']

>>> classmates.append('Adam')          追加元素到表末尾
>>> classmates.insert(1,'Jack')            追加元素到索引号为1的位置
>>> classmates.pop()                           删除列表末尾的元素
>>> classmates.pop(i)                           删除列表中索引 i 的元素
>>> classmates[i]='simom'                     给列表中

若要定义一个空的tuple 可以写成( )： t=( )

但是，要定义一个只有一个元素的tuple，若t=(1),则默认为t=1；正确的写法应该是t=(1,)

一个‘“可变”的tuple：

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

注意：表面上看，tuple的元素确实变了，但其实变得不是tuple的元素，而是list的元素。tuple一开始指向的list并没有指向别的list，所以tuple的“不变”是说，tuple的每个元素，指向永远不变。即指向'a'，就不能指向'b'，指向一个list，就不能指向其他对象，但指向的这个list本身是可变的。

1、list和tuple都可以随意嵌套

2、两者可以通过list( )和tuple( )函数相互转换

• list和tuple常用的内置函数：

list.count（item）   表示统计列表(元组)中item出现的次数
list.index（item）    表示列表（元组）中item第一次出现的索引
list.reverse()            表示原地倒转列表（元组不可以）
list.sort()                  表示对列表内的元素排序（元组不可以）
list._sizeof_()            计算列表（元组）的存储空间

• 元组和列表存储方式的差异：

对列表空间的分配，为了减小每次增加/删除操作是空间分配的开销，Python每次分配空间都会额外多分配一些，（over-allocating）保证其操作的高效性。

• 列表和元组的性能：

1、元组比列表更加轻量级，总体上来说，元组的性能略优于列表；

2、Python会在后台对静态数据做一些资源缓存，初始化一个相同元素的元组比列表快。

但如果是索引操作的话，速度几乎一样

4、条件判断

if 语句的完整形式：

if <条件判断1>:
                     <执行1>
            elif <条件判断2>:
                     <执行2>
            elif <条件判断3>:
                    <执行3>
            else:
                    <执行4>

if语句是从上往下判断，若在某个判断上是 ture，把该判断对应的语句执行后就会忽略剩下的elif和else。

简写

if x:
    print('True')

只要 x 是非零数值、非空字符串、非空list等，就判断为ture，否则为false。

5、循环

（1）for循环

for x in...把每个元素代入变量x，然后执行缩进块语句

range( )

sum = 0                                         #计算1-100的整数和
             for x in range(101):
                     sum = sum + x
             print(sum)

（2）while循环

sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)

break 提前退出循环

continue 跳过当前的这次循环，直接开始下一次循环

都需要配合if 语句

ctrl+c 强制结束python进程

6、字典（dict）和集合（set）

字典：一系列由键（key）和值（value）配对组成的元素的集合，在python3.7+中，字典被确定为有序。

相比于列表和元组，字典的性能更优，特别是对于查找、添加和删除操作，字典都能在常数时间复杂度内完成。是用空间来换取时间的一种方法。

集合：与字典基本相同，唯一区别就是没有键和值的配对，是一系列无序的、唯一的元素组合

创建：

#创建字典
d1 = {'name': 'jason', 'age': 20, 'gender': 'male'}
d2 = dict({'name': 'jason', 'age': 20, 'gender': 'male'})
d3 = dict([('name', 'jason'), ('age', 20), ('gender', 'male')])
d4 = dict(name='jason', age=20, gender='male') 
d1 == d2 == d3 ==d4
True
#创建集合
s1 = {1, 2, 3}
s2 = set([1, 2, 3])          
s1 == s2
True

记：dict中的key必须是不可变对象

访问：

1、直接索引 键
>>>d1['name']
>>>'jason'
2、使用get（key，default）来索引，若键不存在，调用get（）函数可以返回一个默认值（default）
>>>d1.get('location','null')          #location不存在，返回null

注意：集合不支持索引，因为集合本质上是一个哈希表，和列表不一样

判断一个元素是否在字典或者集合内 用 value in dict/set

增加、删除、更新

>>>d['gender'] = 'male'                # 增加元素对'gender': 'male'
>>>d['dob'] = '1999-02-01'           # 增加元素'dob'
>>>d['dob'] = '1998-01-01'            # 更新键'dob'对应的值 
>>>d.pop('dob')                             # 删除键为'dob'的元素对
s = {1, 2, 3}
s.add(4)                                          # 增加元素 4 到集合
s.remove(4)                                    # 从集合中删除元素 4

注意：集合的 pop() 操作是删除集合中最后一个元素，可是集合本身是无序的，你无法知道会删除哪个元素，因此这个操作得谨慎使用。

排序：

对于字典，可以根据键或者值来排序。

>>>d = {'b': 1, 'a': 2, 'c': 10}
              >>>d_sorted_by_key = sorted(d.items(), key=lambda x: x[0])              # 根据字典键的升序排序
              >>>d_sorted_by_value = sorted(d.items(), key=lambda x: x[1])            # 根据字典值的升序排序

对于集合，直接调用sorted（set）即可。

集合：

1、重复元素在set中自动过滤

2、set可以看做数学意义上的无序和无重复元素的集合，所以两个set可以做数学上的交集、并集、等操作

>>> s1 & s2           #交集
            >>> s1 | s2             #并集