int类型 python 输入 python输出int

数据类型分类

• 数字（number）
• 字符串（string）
• 列表（list）
• 字典（dictionary）
• 元组（tuple）
• 集合（sets）

数字

• 整型（int，integer）

• Python3中只有一种整数类型int，表示为长整型，没有Python2中的long；
• 可以表示正数、负数和零；
• 进制：

• 默认使用十进制；
• 使用起始标记后输出时转化为十进制；

进制	起始	基本数
二进制	0b	0~9
八进制	0o	0~7
十六进制	0x	0~9,A~F

• 浮点型（float）

• 组成：整数部分+小数部分；
• 储存不精确：

• 使用浮点数计算时，可能会出现小数位不确定的情况；

print (1.1+2.2)
print (1.1+2.1)

• 解决方案：导入模块decimal；

from decimal import Decimal
print (Decimal("1.1")+Decimal("2.2"))

• 对小数位做保留n位处理：

a = 0.111111
b = "%.2f"%a
print(a,b)

• 此时输出结果为：

0.111111 0.11

• 布尔型（bool，Boolean）

• 用来表示真或者假的值；
• 区别于其他语言：Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加， True==1，False==0 会返回 True，但可以通过 is 来判断类型；

• 举例：

print(1 == True)

• 输出结果为：

True

print(1 is True)

• 输出结果为：

False

• 可转化为整数；

print(True+1)

• 复数型（complex）

• 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点。

字符串

• 用单引号 ’ 、双引号 "或者三引号’''定义；

• 用单双引号定义的字符串必须在同一行；
• 用三引号定义的字符串可以分布在连续的多行；

• 使用反斜杠 \ 转义特殊字符（即转义字符）或者用作续行符；
• 没有单独的字符类型，一个字符就是长度为1的字符串；
• 区别于其他语言，Python语言中字符串不能被改变，比如对某个索引位置赋值，会导致错误。
• 星号 * 表示复制当前字符串，与之结合的数字为复制的次数。

字符串的驻留机制

• 仅保留一份相同且不可变字符串的方法；
• 不同的值被存放在字符串的驻留池中，Python的驻留机制对相同的字符串只保留一份数据，在后续创建相同的字符串时，不会开辟新的内存空间，而是将唯一一份数据的地址赋给新创建的变量；
• 调用sys.intern()方法强制多个字符串指向同一个对象；
• 在需要进行字符串的拼接时建议使用join()方法，而不是+；

• 因为join()方法是先计算出所有字符串的长度，然后再拷贝，只需要新建一次对象，效率更高；

驻留机制发生的几种情况

• 字符串的长度为0或1时；
• 仅由字母、数字、下划线组成的字符串；
• 对于[-5,256]之间的整数数字，Python默认驻留；
• 字符串只在编译时进行驻留，而非运行时。
• 用乘法得到的字符串，如果结果长度<=20且字符串只包含数字、字母、下划线，支持驻留。长度>20，不支持驻留。

驻留机制的优缺点

• 当需要值相同的字符串时，可以直接从驻留池中取用，避免了频繁的创建和销毁，提升效率和节约内存；
• 但同时拼接字符串和修改字符串会影响性能。

字符串的索引值

• 索引值以0为开始值，向后递增1；
• -1为从末尾的开始位置，向前递减1。

字符串的查询操作

• 调用index()方法；

• 查找子串第一次出现的位置；
• 如果查找的子串不存在，则抛出ValueError；

• 调用reindex()方法；

• 查找子串最后一次出现的位置；
• 如果查找的子串不存在，则抛出ValueError；

• 调用find()方法；

• 查找子串第一次出现的位置；
• 如果查找的子串不存在，则返回-1；

• 调用rfind()方法；

• 查找子串最后一次出现的位置；
• 如果查找的子串不存在，则返回-1；

字符串的比较操作

• 使用比较操作符；
• 自首位开始比较，相同时比较下一位；直至两字符不相等时得出结果或直至末位得出结果；
• 比较依据：使用对应的原始值比较；

• 调用ord(X)函数可以得到指定字符的原始值；
• 调用char(num)函数可以得到对应于原始值的字符；

• 判断id（在内存中的地址）是否相等使用is或is not语句

字符串的更改操作

• replace(old, new[, max])方法；

• old：将被替换的子字符串；
• new：新字符串，用于替换old子字符串；
• max：可选字符串, 替换不超过max次；

字符串的合并操作

• 使用加号+连接字符串；
• 使用join()方法合并字符串：

• 举例：

str="-";
seq=("a","b","c");
print(str.join(seq));
//使用str中的值连接seq中的元素

• 输出结果为

a-b-c

字符串内容对齐操作

• center(width[, fillchar])方法：

• 居中对齐；
• 第一个参数为指定宽度，如果设定宽度小于实际宽度，则返回原字符串；
• 第二个参数为指定填充符，默认为空格；

• rjust(width[, fillchar])方法；

• 右对齐；
• 第一个参数为指定宽度，如果设定宽度小于实际宽度，则返回原字符串；
• 第二个参数为指定填充符，默认为空格；

• ljust(width[, fillchar])方法；

• 左对齐；
• 第一个参数为指定宽度，如果设定宽度小于实际宽度，则返回原字符串；
• 第二个参数为指定填充符，默认为空格；

• zfill(width)方法；

• 字符串右对齐，并在前面补充0；
• 参数为指定宽度，如果设定宽度小于实际宽度，则返回原字符串；；

字符串的劈分操作

• split(str, num)方法；

• 自左向右劈分；
• 返回值为一个列表；
• 第一个参数为分隔符，默认为空字符，包括空格、换行(\n)、制表符(\t)等；
• 第二个参数为分割次数。默认为-1, 即分隔所有；经过最大劈分次数后剩余的子串会单独作为一部分；

• rsplit(str, num)方法

• 自右向左劈分；
• 返回值为一个列表；
• 第一个参数为分隔符，默认为空字符，包括空格、换行(\n)、制表符(\t)等；
• 第二个参数为分割次数。默认为-1, 即分隔所有；经过最大劈分次数后剩余的子串会单独作为一部分；

字符串的切片操作

• 语法格式：

str[start:stop:step]

• 当未指定参数时，默认从首位开始，末位结束，步长为一；
• 当步长为负数时，从后向前切片；

• 切片操作将产生新的对象；

字符串大小写转换操作

• capitalize()

• 将字符串的第一个字符转换为大写；

• title()

• 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写；

• upper()

• 转换字符串中的小写字母为大写；

• lower()

• 转换字符串中所有大写字符为小写；

• swapcase()

• 将字符串中大写转换为小写，小写转换为大写；

字符串的判断操作

• isidentifier()

• 判断指定字符串是否为合法的标识符；

• isspace()

• 判断指定字符串是否全部由空白字符组成；

• isalpha()

• 判断指定字符串是否全部由字母（包括汉字）组成；

• isdecimal()

• 判断指定字符串是否全部由十进制（只认阿拉伯数字）组成；

• isnumeric()

• 判断指定字符穿是否全部由数字（任何语言的数字）组成；

• isalnum()

• 判断指定字符穿串是否全部由字母（包括汉字）和数字组成；

格式化字符串

• 在Python中字符串格式化与C语言中printf()函数语法相同；
• 占位符：

• 使用%做占位符；

• 语法格式：

print("格式化符号"%(实际值))

• 格式化符号：

符号	描述	举例
%s	格式化字符串
%d	格式化整数，可指定宽度	%10d：宽度为10， 位数不够时自左用空格填充
%f	格式化浮点数字，可指定小数点后的精度	%10.3d：宽度为10， 保留小数点后3位， 小数位数不够时向右用0填充
%e	用科学计数法格式化浮点数

• 使用{}做占位符；

• 语法格式：

print("{0}{1}".format(实际值1,实际值2))

• 举例：

print("{0:.1}".format(3.1415926))
print("{0:.3f}".format(3.1415926))
print("{0:10.3f}".format(3.1415926))

• 输出结果为：

3e+00
//“e+00”表示10的0次方
3.142
     3.142

字符串的编码与解码

• 编码：

• 语法格式：

str.encode([encoding=""][,errors=""])

• 指定进行编码时采用的字符编码，该选项默认采用utf-8 编码。例如，如果想使用简体中文，可以设置 gb2312；当方法中只使用这一个参数时，可以省略前边的“encoding=”，直接写编码格式，例如str.encode(“UTF-8”)；
• errors指定错误处理方式，其可选择值可以是：

• strict：遇到非法字符就抛出异常；
• ignore：忽略非法字符；
• replace：用“？”替换非法字符；
• xmlcharrefreplace：使用 xml 的字符引用；
• 该参数的默认值为 strict；

• 解码：

• 语法格式：

bytes.decode([encoding="utf-8"][,errors="strict"])

• 指定解码时采用的字符编码，默认采用 utf-8 格式。当方法中只使用这一个参数时，可以省略“encoding=”，直接写编码方式即可；
• 注意，对bytes类型数据解码，要选择和当初编码时一样的格式。
• errors指定错误处理方式，其可选择值可以是：

• strict：遇到非法字符就抛出异常；
• ignore：忽略非法字符；
• replace：用“？”替换非法字符；
• xmlcharrefreplace：使用 xml 的字符引用；
• 该参数的默认值为 strict；

转义字符

• 定义：反斜杠+想要实现的转义功能首字母。
• 用途（为什么需要转义字符）：

• 当字符串中包含反斜杠、单引号和双引号等有特殊用途的字符时，必须使用转义字符对这些字符进行转义（转换一个含义），举例：

• 反斜杠\\

print('http:\\www.baidu.com')

• 输出结果为：

http:\www.baidu.com

• 单引号\’
• 双引号\"

• 当字符串中包含回车、换行、水平制表符或退格等无法直接表示的特殊字符时，也可以使用转义字符。举例：

• 换行\n (newline)

print('Hello\nworld!')

• 输出结果为：

Hello
world!

• 回车\r (return)，会使后面的内容覆盖前面的内容；

print('Hello\rworld!')

• 输出结果为：

world!

• 水平制表符\t (tab)，输出结果为占据下一个制表位（四个空格）剩余位置的间隔；

print('Hello\tworld!')

• 输出结果为：

Hello   world!//中间实际上只有三个空格的位置

• 退格\b (backspace)，退一个格继续输出

print('Hello\bworld!')

• 输出结果为：

Hellworld!

原字符

• 定义：不希望字符串中的转义字符生效时，使用原字符；
• 操作：在字符串前加上“r”或“R”；
• 注意：使用原字符时，后接字符串的最后一位不能为反斜线，连续两（偶数）个反斜杠可以；
• 举例：

print(r'Hello\nworld!')

• 输出结果为：

Hello\nworld!

列表

• 是Python中最基本的数据结构；
• 相当于其他语言中的数组；

特点

• 元素按顺序有序排列；
• 索引映射唯一的数据；
• 可以重复存储数据；
• 任意数据类型混存；
• 根据需要动态分配和回收内存。

创建列表

• 方法一：使用中括号[]，元素之间用英文逗号“,”分隔开；

• 举例：

list_1=['red','green','blue']

• 方法二：调用内置函数list()；

• 举例：

list_1=list(['red','green','blue'])

• 方法三：列表生成式；

• 语法格式：

[变量表达式 for 变量 in range(start,stop,step)]

• 举例：

list=[i*i for i in range(0:5:2)]

• 相当于：

[0, 4, 16]

获取指定元素的索引

• 调用index()方法：

• 如果列表中存在N个相同的元素，只返回相同元素中的第一个元素值的索引；
• 如果查询的元素在列表中不存在，则抛出

ValueError:'X' is not in list

• 可以在指定的start和stop之间进行查找；

• 举例：

• 例一：

list=['red','green','blue','yellow','white','black']
print(list.index("red",1,5))

• 抛出：

ValueError:'red' is not in list

• 例二：

list=['red','green','blue','yellow','white','black']
print(list.index("red"))

• 输出结果为：

0

获取列表中的元素

• 与字符串类似，列表中的每个值都有对应的位置值，称之为索引;
• 通过索引列表可以进行截取、组合等操作。
• 从前向后，列表第一个位置的索引是0，向后递增1；
• 从后向前，列表最后一个位置的索引是-1，向前递减1；
• 指定的索引不存在时，抛出indexError.

• 举例：

• 例一：

list=['red','green','blue','yellow','white','black']
print(list[0])
print(list[1])
print(list[2])

• 输出结果为：

red
green
blue

• 例二：

list=['red','green','blue','yellow','white','black']
print(list[-1])
print(list[-2])
print(list[-3])

• 输出结果为：

black
white
yellow

• 获取多个元素(切片)：

• 语法格式：

list[start:stop:step]

• 切片的结果；原列表中片段的拷贝；
• 切片的范围：[start,stop)；
• step：

• 默认值为1；
• 当值为正数时，从start开始的向后切片；

• [:stop:step]切片的第一个元素默认时列表的第一个元素；
• [start::step]切片的最后一个元素默认是列表的最后一个元素；

• 当值为负数时，其余两参数也对应为负数，从start开始的向前切片；

• [:stop:step]切片的最后一个元素默认是列表的第一一个元素；
• [start::step]；切片的第一个元素默认时列表的最后一个元素；

判断指定元素在列表中是否存在

• 语法结构：

• 元素 in 列表名；
• 元素 not in 列表名；

增加列表元素

• append()方法；

• 在列表的末尾添加一个元素；
• 举例：

list=['red','green','blue']
list.append('yellow')
print(list)

• 输出结果为：

['red','green','blue','yellow']

• extend()方法；

• 在列表的末尾至少添加一个元素；
• 举例：

list_1=['red','green','blue']
list_2=['yellow','white','black']
list_1.extend(list_2)
print(list_1)

• 输出结果为：

['red','green','blue','yellow','white','black']

• insert()方法；

• 在列表的任意位置添加一个元素；
• 举例：

list=['red','green','blue']
list.insert(1,'yellow')
print(list)

• 输出结果为：

['yellow','red','green','blue']

• 切片；

• 在列表的任意位置至少添加一个元素；
• 举例：

list_1=['red','green','blue']
list_2=['yellow','white','black']
list_1[3:]=list_2
//list_1的元素从第四个位置开始切换为list_2的全部元素
print(list_1)

• 输出结果为：

['red','green','blue','yellow','white','black']

删除列表元素

• 使用del语句来删除列表的元素或者删除整个列表：

• 举例：

• 例一：

list=['red','green','blue']
del list[1]
print(list)

• 输出结果为：

['green','blue']

• 例二：

list_1=['red','green','blue']
del list_1
print(list_1)

• 输出结果为：

NameError: name 'list_1' is not defined.

• remove()方法：

• 一次删除一个元素；
• 重复元素只删除第一个；
• 元素不存在时抛出ValueError;
• 举例：

list=['red','green','blue']
list.remove["red"]
print(list)

• 输出结果为：

['green','blue']

• pop()方法：

• 删除一个指定索引位置上的元素；
• 指定索引不存在时抛出IndexError；
• 不指定索引时删除列表中的最后一个元素；
• 举例：

list=['red','green','blue']
temp=list.pop(1)
print(list)
print(temp)

• 输出结果为：

['red', 'blue']
green

• 切片：

• 一次最少删除一个元素；
• 举例：

list=['red','green','blue']
list[1:2]=""
print(list)

• 输出结果为：

['red', 'blue']

• clear()：

• 清空列表元素；
• 举例：

list=['red','green','blue']
list.clear()
print(list)

• 输出结果为：

[]

更改列表元素

• 对列表中指定索引的元素重新赋值；

• 举例：

list=['red','green','blue']
list[1]='yellow'
print(list)

• 输出结果为：

['yellow','green','blue']

• 对列表中指定切片重新赋值；

• 举例：

list_1=['red','green','blue']
list_2=['yellow','white','black']
list_1[1:]=list_2
print(list_1)

• 输出结果为：

['red', 'yellow', 'white', 'black']

列表元素的排序操作

• 调用sort()方法；

• 默认为从小到大的顺序进行排序；
• 可以指定"reverse=True"，进行降序排序；
• 不生成新列表，在原列表的内存空间进行操作；
• 举例：

list=[1,8,5,3,5,7,7]
list.sort()
print(list)
list.sort(reverse=True)
print(list)

• 输出结果为：

[1, 3, 5, 5, 7, 7, 8]
[8, 7, 7, 5, 5, 3, 1]

• 调用内置函数sorted()；

• 可以指定"reverse=True"，进行降序排序，原列表不发生改变；
• 生成新的列表对象；
• 语法结构：

sorted(iterable, key=None, reverse=False)

• iterable：可迭代对象；
• key：主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序；
• reverse：排序规则，reverse = True 降序 ， reverse = False 升序（默认）；

• 举例：

list_1=[1,8,5,3,5,7,7]
list_2=sorted(list_1,reverse=True)
print(list_2)

• 输出结果为：

[8, 7, 7, 5, 5, 3, 1]

• 调用reverse()方法：

• 无返回值，对列表元素反向排序；
• 不生成新列表，在原列表的内存空间进行操作；

字典

• 一种可变容器模型，可以存储任意类型的对象；
• 以键值对的方式存储数据；
• 字典是一个无序的序列；
• 键必须是唯一的，但值则不必
• 存储时使用哈希函数计算存储位置，这也就要求key为不可变序列；
• 值可以取任何数据类型，但键必须是不可变的，如字符串，数字；
• 会浪费较大的内存，是一种空间换时间的数据结构；

创建字典

• 方法一：

dict={key1:value1,key2:value2,key3:value3}

• 每个键值key=>value对用冒号: 分割，每个对之间用逗号,分割，整个字典包括在花括号{}中；；
• 举例：

dict={'name':'Lee','age':24}

dict={}
//空字典

• 方法二：使用内置函数dict()

dict_1=dict(name="Lee",age=25)

• 方法三：使用内置函数zip()以及字典生成式

• zip()函数用于将可迭代的对象作为参数，将对象中的对应的元素打包成一个元组，然后返回由这些元素组成的列表；
• 语法格式：

dict={表示字典key的变量:表示字典value的变量 for 表示字典key的变量,表示字典value的变量 in zip(字典key所在对象,字典value所在对象)}

• 举例：

items=['name','age']
prices=["lee",24]
dict={item:price for item,price in zip(items,prices)}
print(dict)

• 输出结果为：

{'name': 'lee', 'age': 24}

获取字典中的元素

• 使用[]取值：

• 如果字典中不存在指定的key，则抛出keyError；

• 调用get()方法取值：

• 如果字典中不存在指定的key，将返回None；
• 通过参数设置不存在时返回的值；
• 举例：

dict={'Name':'Lee','Age':24}
print('Salary:',dict.get('Salary'))

• 此时由于没有设置Salary，将输出：

Salary:None

判断给定的key是否在字典中

• 使用in与not in进行判断；

字典元素的删除

• 使用del语句；

• 举例

dict={'Name':'Lee','Age':24}
del dict["Name"]
print(dict)

• 输出结果为：

{'Age': 24}

• 调用clear()方法清空字典元素：

• 举例

dict={'Name':'Lee','Age':24}
dict.clear()
print(dict)

• 输出结果为：

{}

字典元素的新增

• 增加新的键值对；
• 举例

dict={'Name':'Lee','Age':24}
dict["Salary"]=0.0
print(dict)

• 输出结果为：

{'Name': 'Lee', 'Age': 24, 'Salary': 0.0}

字典元素的更改

• 对已有键值对进行修改；
• 举例

dict={'Name':'Lee','Age':24}
dict["Age"]=25
print(dict)

• 输出结果为：

{'Name': 'Lee', 'Age': 25}

获取字典视图

• 视图对象都是只读的；
• 字典改变，视图也会跟着改变；
• 获取方法：

• keys()方法：获取字典中所有的key；
• values()方法：获取字典中所有的value；
• items()方法；获取字典中所有的键值对；

字典元素的遍历

• 举例：

dict={'Name':'Lee','Age':24}
for item in dict:
    print(item,dict[item])

• 输出结果为：

Name Lee
Age 24

元组

• python内置的数据结构之一，是一个不可变序列，即元组的元素不能修改；
• 元组中存储的时对象的引用：

• 元组中的对象是不可变序列时，不可改为引用其他对象；
• 元组中的对象是可变序列时，不可改为引用其他对象，但该可变序列的数据可以改变。

• 元组的索引、截取操作与字符串基本相同；

为什么将元组设置为不可变序列

• 在多任务环境下，同时操作对象时不需要加锁；

元组的创建

• 在()内添加元素，并使用逗号隔开；
• 注意：元组内只有一个元素时，需要在元素后面添加逗号, ，否则括号会被当作运算符使用；
• 举例：

• 例一：

tuple=('Lee',25)

• 例二：

tuple=()
//创建空元组

访问元组中的值

• 下标索引从0开始，利用索引可以进行截取、组合等操作；
• 举例：

tuple=('Lee',25)
print(tuple[1])

• 输出结果为：

25

修改元组

• 元组中元素值不允许修改，但可以对元组进行连接组合；
• 举例：

tuple_1=('Lee',)
tuple_2=(25,)
tuple_3=tuple_1+tuple_2
print(tuple_1)

• 输出结果为：

('Lee',25)

删除元组

• 元组中的元素不允许删除，但可以使用del语句来删除整个元组：
• 举例：

tuple_1=('Lee',25)
del tuple_1
print(tuple_1)

• 输出结果显示

NameError: name 'tuple_1' is not defined

元组的遍历

tuple=('Lee',25)
for item in tuple:
    print(item)

输出结果为：

Lee
25

集合

• 是一个无序的不重复元素序列；
• 存储时使用哈希函数计算存储位置；

创建集合

• 方法一：使用{}；

• 不可用于创建空集合；
• 语法格式：

parame = {value01,value02,...}

• 方法二：使用set()函数进行强制转换；

• 语法格式：

set(value)

• 举例：

name=set('lee')
num_1=set([1,85,35,7,7])
num_2=set((1,85,35,7,7))
num_2=set((1,85,35,7,7))
num_3=set({1,85,35,7,7})
print(name)
print(num_1)
print(num_2)
print(num_3)

• 输出结果为：

{'l', 'e'}
{1, 35, 85, 7}
{1, 35, 85, 7}
{1, 35, 85, 7}

判断元素是否存在

• 使用in与not in判断

添加元素

• 调用add()方法；

• 语法格式：

set.add(x)

• 如果元素已存在，则不进行任何操作；

• 调用update()方法；

• 语法格式：

set.update(X,X,X,X)

• 参数可以为列表、元组、字典等；

移除元素

• 调用remove()方法；

• 当元素不在该集合中时，抛出KeyError；

• 调用discard()方法；
• 调用pop()方法；

• 随机删除元素，无法指定元素；

• 调用clear()方法；

• 清空整个集合；

集合之间的关系

• 相等：使用==或!=进行判断；
• 是否为另一个集合的自子集：调用issubset()方法进行判断；
• 是否为另一个集合的超集：调用issuperset()方法进行判断；
• 两个集合是否没有交集：调用isdisjoint()方法进行判断；

集合的数学操作

• difference()，返回集合的差集；
• intersection()，返回集合的交集；
• union()，返回集合的并集；
• symmetric_difference()，返回集合的对称差集；
• |，两集合中包含的所有元素；
• &，两集合中都包含的元素；
• ^，不同时包含于两集合中的元素；
• -，前一集合中包含，而后一集合中没有的元素；

集合生成式

• 语法结构：

{变量表达式 for 变量 in range(start,stop,step)}