int(整型) - 整型包含了数字中所有的整数，包括正整数、负整数和0；例如: 0, 10, -100, +28

float(浮点型) - 浮点型包含数字中所有的小数; 例如: 0.0, 0.12, -3.14，并且支持科学计数法: 2e3

bool(布尔) - 布尔只有True和False两个值；实质，当布尔参与数字运算的时候True就是1，False就是0

str(字符串) - str是python自己提供的一种容器型数据类型，一个字符串中可以存储多个字符

补充：complex(复数) - 复数是指包含实部和虚部的这种数： 10+2j, 19j, -10j,实部+虚部j, 注意：j 前面必须有数字，不能省略

获取数据类型: type() - type(数据) - 获取括号中执行的数据对应的类型

print(type('s')) # str类型
print(type(10+2j)) # complex类型

判断是否是指定的类型：isinstance() - isinstance(数据, 类型) - 判断指定的数据是否是指定的类型，结果是布尔值

print(isinstance(4, str)) # False
print(isinstance(5.555, float)) # True

类型转换: 类型名() - 类型名(数据) - 将指定的数据转换成指定的类型

print(int(6.666)) # 将6.666转换成整型，结果为6

range函数 - 注意:xrange是python2.x的语法，在python3.x无效

range(N) - N是正整数，产生0~N-1的所有整数

for num in range(10):
    print(num) # 0~~9

range(M,N) - M,N都是整数，并且N>M,产生M~N-1的所有整数

for num in range(100, 1000):
    print(num) # 100~~999

range(M,N,S) - M,N,S都是整数，产生M~N-1,每次加S来产生下一个数

for num in range(0, 101, 3):
    print('---:', num) # ---:0→---:3~~---:99

导入random模块:random是python内置的一个专门用来产生和处理随机数的模块

random(M,N) - 产生M~N的随机数，要求M,N都是整数，并且N>M

import random
random_num = random.randint(0, 10)
print('随机数：', random_num)

continue - continue是Python关键字，只能用在循环体中！

功能：执行循环体执行到continue的时候，结束当次循环，直接进入下次循环的判断（for循环就是让变量去取下一个值；while循环就是直接去判断while后面的条件是否为True）

for x in range(10):
if x % 3 == 0:
    continue
print(x)
print('---')

break - break是Python关键字，只能用在循环体中！

功能：执行循环体的时候，遇到break，整个循环结束，直接执行循环后面的其它语句

for x in range(10):
    print(x)
    break
    print('!!!')
# print(x)
print('结束！')

else - 语法:

"""
for 变量 in 序列:
    循环体 
else:
    语句块  


while 条件语句:
    循环体 
else:
    语句块

"""

执行过程：如果循环自然死亡，else对应的语句块会执行；如果循环因为遇到break而结束，else对应的语句块不执行

for x in range(5):
    print(x)
    break
else:
    print('循环结束,没有遇到break')

补充：循环嵌套：在循环体中又有循环结构

执行过程：外循环执行一次，内循环执行完

for x in range(5): # 外循环
    for y in range(4): # 内循环
        print(x, end=' ')
        print(y, end=' ')
    if (x == 1):
        break

"""
x = (0,1,2,3,4)
x = 0     y = (0,1,2,3)
          y = 0  print(0), print(0)
          y = 1  print(0), print(1)
          y = 2  print(0), print(2)
          y = 3  print(0), print(3)

x = 1     y=(0,1,2,3)
...

输出:0 0 0 1 0 2 0 3 1 0 1 1 1 2 1 3 
"""

字符编码相关的函数:

a. chr(编码值) - 获取编码对应的字符

print(chr(0x4e45))  # 久

b. ord(字符) - 获取字符的编码(以十进制的形式返回) 注意: 一个字符

print(ord('冰'), ord('凉'))  # 十进制  20912 20937
print(ord('a'))  # 97

len(序列) — 获取序列长度，获取序列中元素的个数

len(字符串) — 获取字符串的长度(字符的个数)，结果是一个整数

n = [1, 2, 3]
print(len(n)) # 3
print(len('abcd')) # 4

占位符

%s(字符串)

%d(整数)

%f(小数) - %.Nf 保留小数点后N位小数

%c(字符) - 可以将数字转换成字符

% —— 固定写法

() —— 固定写法，字符串中只有一个占位符的时候，这个括号()可以省略

括号中的值 — 值和占位符要一一对应（个数、类型、位置都要对应）

增（添加列表元素）

.append

列表.append（元素） —— 在指定的 列表 的最后添加指定的 元素

animes = ['一人之下', '火隐忍者', '斗破苍穹', '尸兄']  # animes是 动漫 的意思
animes.append('七龙珠')
print(animes)  # ['一人之下', '火隐忍者', '斗破苍穹', '尸兄', '七龙珠']  增加'七龙珠到'animes当中

.insert

列表.insert（下标，元素） —— 在指定的 下标前 插入指定的元素

animes.insert(2,'犬夜叉')  # 添加到下标为2（斗破苍穹）之前
print(animes)  # ['一人之下', '火隐忍者', '犬夜叉', '斗破苍穹', '尸兄', '七龙珠']

删（删除元素）

del

del 列表[下标] —— 删除列表中指定下标对应的元素

注意：del是Python中的关键字，可以用它删除任何数据，这儿的下标不能越界

# del animes[-100]  # 下标不可越界，报错
del animes[-2]  # 删除下标为-2（尸兄）
print(animes)   # ['一人之下', '火隐忍者', '犬夜叉', '斗破苍穹', '七龙珠']

remove

列表.remove（元素） —— 删除列表中第一个指定元素

注意：被删除的元素在列表中必须是存在的

animes = ['一人之下', '火隐忍者', '一人之下', '斗破苍穹', '尸兄']  # animes是 动漫 的意思
animes.remove('一人之下')  # 删除列表中第一个指定元素'一人之下'
# animes.remove('死神')  # 被删除的元素在列表中必须是存在的，报错ValueError: list.remove(x): x not in list
print(animes)  # ['火隐忍者', '一人之下', '斗破苍穹', '尸兄']

.pop

列表.pop() —— 将列表中最后一个元素 取出，会返回取出来的元素

列表.pop(下标) —— 将列表中 指定下标对应的元素 从列表中取出，会返回取出来的元素

del_item = animes.pop()
print(animes, del_item)  # ['火隐忍者', '一人之下', '斗破苍穹'] 尸兄

del_item = animes.pop(0)
print(animes, del_item)  # ['一人之下', '斗破苍穹'] 火隐忍者

改（修改元素的值）

列表[下标] = 新值 —— 修改列表中指定下标对应的值

list1 = [1, 2, 3]
list1[0] = 'abc'   # 1的下标为0
print(list1)  # ['abc', 2, 3]

相关运算：

数学运算+，*

列表1+列表2 —— 将两个列表中的元素合并在一起产生一个新的列表

列表*N —— 列表中的元素重复N次，产生一个新的列表

list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
print(list1 + list2)  # [1, 2, 3, 'a', 'b', 'c']
print(list1 * 2)  # [1, 2, 3, 1, 2, 3]

支持比较运算,比较大小的原理和字符串类似

print([1, 2, 3] == [2, 1, 3])  # False
print([1, 2, 3] == [1, 2, 3])  # True

★了解!

in / not in

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

print([1, 2] in [1, 2, 3])  # False
print([1, 2] in [[1, 2], 30, 'abc'])  # True
print('abc' in [10, 'abc', True])  # True

len

len(列表) —— 获取列表中元素的个数

print(len([[1, 'a'], 2, '100', True]))  # 4

list

list（数据） —— 将其它数据转换成列表；只有 序列 才可以转换成列表，转换的时候就是将序列中所有的元素转换成列表的元素

★注意 list = 10 - 不能用Python给我们提供的类型的名字来命名，否则后期会有隐患

list1 = list('hello')
print(list1)  # ['h', 'e', 'l', 'l', 'o']

list2 = list(range(11, 21))
print(list2)  # [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

序列的其它方法

max（序列） —— 获取序列中值最大的元素

min（序列） —— 获取序列中值最小的元素

sum（序列） —— 求序列中所有元素的和

注意：以上三种方法，要求序列中的元素类型必须一致，并且这个类型支持比较运算和加法运算（一般数字序列用）

print(max([19, 89, 999, 2, 0.2]))  # 999
print(min([19, 89, 999, 2, 0.2]))  # 0.2
print(sum([19, 89, 999, 2, 0.2]))  # 1109.2
print(sum(range(101)))  # 5050

len(字符串) - 求字符串长度

str(数据) - 将其他数据转换成字符，所有的数据都能转换成字符串, 转换的时候直接在数据的外面加引号

print(int('+23'))   # 只有去掉引号后，本身就是一个整数的字符串才能转换成整型
print(float('124.0'))   # 只有去掉引号后，本身就是一个数字的字符串才能转换成浮点型
print(bool(''))    # 除了空串会转换成False,其他的都会转换成True
str2 = ''
if str2:
    print('不是空串')

字符串.capitalize() - 将字符串中首字母大写

str4 = 'hello'
new_str = str4.capitalize()
print(new_str) # Hello

字符串.center(width, fillchar) - 产生一个长度为width的新的字符串，新字符串中原字符串居中，剩余的部分用fillchar填充

new_str = str4.center(11, '0')
print(new_str) # 000hello000

new_str = str4.center(11, '*')
print(new_str) # ***hello***

new_str = str4.center(11, ' ')
print(new_str) # “   hello   ”

字符串.ljust(width, fillchar)

new_str = str4.ljust(11, '=')
print(new_str) # hello======

字符串.rjust(width, fillchar)

# py1901001\py1901002\py1901010
num = 1    # 001
# num = 10   # 010
study_id = str(num).rjust(3, '0')
print(study_id) # 001

字符串.zfill(width) - 产生一个宽度是width的字符串，原字符串在右边，前用0填充

study_id = str(num).zfill(4)
print(study_id) # 0001