目录

• 数据类型
• • 整数类型（int）
  • 小数/浮点数（float）
  • 复数类型（complex）
• 字符串
• • • 字符串的截取
  • 待补充
• List（列表）
• • 遍历
  • 增删改查
  • • 增加(append()、extend()、insert())
    • 删除(del、pop()、remove())
    • 修改
    • 查找(in、not in)
    • 遍历
  • index()
  • count()
  • reverse()
  • sort()
• Tuple(元组)
• • 增（连接）
  • 删除
  • 修改
  • 访问元素
• Dict(字典)
• • 增
  • 删除&清空
  • 改
  • 访问数据
  • 遍历
• Set集合
• 列表、元组、字典、集合区别
• 输出
• • print()
  • 指定最小输出宽度
  • 指定对齐方式
  • 指定小数精度
  • 强制类型转换
• 运算符
• • 算术运算符
  • 赋值运算符&比较运算符
  • 逻辑运算符
  • 三目运算符（三元运算符）
  • 成员运算符
  • 身份运算符
• 流程控制
• • 条件判断语句
  • • • 注意：不要忘记缩进，同一代码块缩进量要相同
  • 循环语句
  • • if 循环语句
    • while 循环语句
    • break、continue和pass
• 函数

数据类型

整数类型（int）

x = 108
print(x)
print(type(x))
y = 888888888888888888888
print(y)
print(type(y))

不管对于多大或者多小的整数，Python 只用一种类型存储，就是 int。

运行结果：

小数/浮点数（float）

Python 小数的指数形式的写法为：

aEn 或 aen

a 为尾数部分，是一个十进制数；n 为指数部分，是一个十进制整数；E或e是固定的字符，用于分割尾数部分和指数部分。整个表达式等价于 a×10^n。

只要写成指数形式就是小数，即使它的最终值看起来像一个整数。例如 108E3 等价于 108000，但 108E3 是一个小数。

a = 10.8
print("a的值：",a)
print("a的类型：",type(a))
b = 108E2
print("b的值：",b)
print("b的类型：",type(b))
c = 0.21565616849658495316616
print("c的值：",c)
print("c的类型：",type(c))

运行结果：

复数类型（complex）

复数由实部（real）和虚部（imag）构成，在 Python 中，复数的虚部以j或者J作为后缀，具体格式为：

a + bj

a 表示实部，b 表示虚部。

c1 = 12 + 0.2j
print("c1Value: ", c1)
print("c1Type", type(c1))

c2 = 6 - 1.2j
print("c2Value: ", c2)

#对复数进行简单计算
print("c1+c2: ", c1+c2)
print("c1*c2: ", c1*c2)

运行结果：

c1Value:  (12+0.2j)
c1Type <class 'complex'>
c2Value:  (6-1.2j)
c1+c2:  (18-1j)
c1*c2:  (72.24-13.2j)

字符串

• Python 中的字符串必须由双引号" "或者单引号’ '包围
• 当字符串内容中出现引号时，我们需要进行特殊处理

1. 对引号进行转义在引号前面添加反斜杠\就可以对引号进行转义

str = 'I\'m your friend.'
print(str)

运行结果：
I’m your friend.

2. 使用不同的引号包围字符串
   如果字符串内容中出现了单引号，那么就可以使用双引号包围字符串，反之亦然。

字符串的截取

#[起始位置:结束位置:步进值]

str = "HelloWorld"
print(str)
print(str[1])#e
print(str[0:4])#Hell
print(str[1:8:2]) #elWr
print(str[8:])#ld
print(str[:8])#HelloWor

待补充

List（列表）

列表中可以存储不同类型

namelist = ["小张","小陈","小林"]
print(namelist[0])
print(namelist[1])
print(namelist[2])
print("==============")
testlist = [108,"小张"]
print(testlist[0],"->",type(testlist[0]))
print(testlist[1],"->",type(testlist[1]))

遍历

• for循环

for name in namelist:
    print(name)

• while循环

length = len(namelist)
i = 0
while i<length:
    print(namelist[i])
    i+=1

增删改查

增加(append()、extend()、insert())

• 用append()

namelist = ["小张","小陈","小林"]

print("-----增加前·列表的数据------")
for name in namelist:
    print(name,end="\t")
name = input("\n请输入增加的名字：")
namelist.append(name);    #在末尾追加一个元素
print("-----增加后·列表的数据------")
for name in namelist:
    print(name,end="\t")

a = [1,6]
b = [2,8]
a.append(b) #将列表当做一个元素，嵌套在a列表中
print(a)

• 用extend()

a = [1,6]
b = [2,8]
a.extend(b) #将b列表中的每个元素逐一追加到a列表的末尾
print(a)

• 用insert()指定下标位置插入元素

a = [1,2,4,5]
a.insert(2,3) #insert(下标,元素/对象) 指定下标位置插入元素
print(a)

删除(del、pop()、remove())

bookName = ["红楼梦","三国演义","活着","水浒传","西游记","活着"]
print("-----删除前·列表的数据------")
for name in bookName:
    print(name,end="\t")
print("\n")
#del bookName[2]  #在指定位置删除一个元素
#bookName.pop() #弹出末尾最后一个元素
#bookName.pop(1) #弹出指定的一个元素
bookName.remove("活着") #直接删除指定内容的元素,若列表中有相同内容的元素，只会删除第一个重复的
print("-----删除后·列表的数据------")
for name in bookName:
    print(name,end="\t")

修改

namelist = ["小张","小陈","小林"]

print("-----修改前·列表的数据------")
for name in namelist:
    print(name,end="\t")
print("\n")
namelist[2]="小周"
print("-----修改后·列表的数据------")
for name in namelist:
    print(name,end="\t")

查找(in、not in)

namelist = ["小张","小陈","小林"]
findName = input("请输入要查找的名字：")
if findName in namelist:
    print("找到了")
else:
    print("没找到")

遍历

这里举个用枚举的例子

list = {"aa","bb","cc","dd"}
for i,x in enumerate(list):
    print(i+1,x)

index()

list = ["a","b","c","d","a"]
#查找指定范围下的元素，并返回对应数据的下标
print(list.index("a",0,3))#范围区间:左闭右开[1,3)

count()

list = ["a","b","c","d","a"]
print(list.count("a"))#统计某个元素出现几次

reverse()

a = [1,2,3,4]
print("反转前：",a)
a.reverse() #将列表所有元素反转
print("反转后：",a)

sort()

b = [5,8,4,1]
print("原列表：",b)
b.sort() #升序
print("升序：",b)
b.sort(reverse=True) #降序
print("降序：",b)

Tuple(元组)

元组和列表（list）的不同之处在于：

• 列表的元素是可以更改的，包括修改元素值，删除和插入元素，所以列表是可变序列；
• 而元组一旦被创建，它的元素就不可更改了，所以元组是不可变序列。

当创建的元组中只有一种数据类型的元素时，该元素后面必须要加一个逗号，这样才是元组

a = (11,)
b = (11)
print(type(a)) #<class 'tuple'>
print(type(b)) #<class 'int'>

增（连接）

tup1 = (12,34,56)
tup2 = ("aa","bb","cc")

tup = tup1+tup2
print(tup) #(12, 34, 56, 'aa', 'bb', 'cc')

删除

tup1 = (12,34,56)
del tup1  # 删除了整个元组变量
print("删除后",tup1) #NameError: name 'tup1' is not defined

修改

元组是不可变序列，元组中的元素不能被修改，所以我们只能创建一个新的元组去替代旧的元组。或对原元组重新赋值。

访问元素

略，和列表大同小异

Dict(字典)

字典（dict）是一种无序的、可变的序列，它的元素以“键值对（key-value）”的形式存储。相对地，列表（list）和元组（tuple）都是有序的序列，它们的元素在底层是挨着存放的。

info = {"name":"小张","age":18,"sex":"男"}
#字典的访问
print(info["name"])
#访问了不存在的键
#print(info["mobile"])#会报错
#用get()访问，没有找到可以设置默认值，否则默认值不会发挥作用
print(info.get("age",20))
print(info.get("mobile","123456789"))

增

student = {"name":"小张","age":19}
newID = input("请输入新学号：")
student["id"] = newID
print(student["id"])

删除&清空

#删除指定键值对，删除后访问会报错
del student["name"]
#删除字典,删除后访问会报错
del student

student = {"name":"小张","age":19}
#clear--清空
print("清空前：",student)
student.clear()
print("清空后：",student)

改

student = {"name":"小张","age":25}
student["age"] = 18
print(student["age"])

访问数据

info = {"name":"小张","age":18,"sex":"男"}
print(info.keys()) #得到所有的键（列表）
print(info.values()) #得到所有的值（列表）
print(info.items()) #得到所有的项（列表），每个键值对是一个元组

遍历

#遍历所有的键
for key in info.keys():
    print(key,end="\t")

#遍历所有的值
for value in info.values():
    print(value,end="\t")

#遍历所有的键值对
for key,value in info.items():
    print("key=%s,value=%s"%(key,value))

Set集合

和数学中的集合概念一样，用来保存不重复的元素，即集合中的元素都是唯一的，互不相同。

列表、元组、字典、集合区别

输出

print()

print("Hello World")

• 同时输出多个变量和字符串

name = "小张"
age = 18
print("姓名：",name,"年龄：",age)

运行结果：

age = 18
print("我今年%d岁"%age)

print("我的名字是%s，我的国籍是%s"%("小张","中国"))

运行结果：

• 若想改变默认的分隔符，可通过 sep 参数进行设置

print("www","baidu","com",sep=".")

运行结果：

• 在默认情况下，print() 函数输出之后总会换行，这是因为 print() 函数的 end 参数的默认值是“\n”，这个“\n”就代表了换行。如果希望 print() 函数输出之后不会换行，则重设 end 参数即可

print("Hello",end="")
print("World",end="\t")
print("Python",end="\n")
print("end")

运行结果：

指定最小输出宽度

使用下面的格式指定最小输出宽度（至少占用多少个字符的位置）：
%10d 表示输出的整数宽度至少为 10；
%20s 表示输出的字符串宽度至少为 20。
对于整数和字符串，当数据的实际宽度小于指定宽度时，会在左侧以空格补齐；当数据的实际宽度大于指定宽度时，会按照数据的实际宽度输出。

指定对齐方式

补充：

• 对于整数，指定左对齐时，在右边补 0 是没有效果的，因为这样会改变整数的值。
• 对于小数，以上三个标志可以同时存在。
• 对于字符串，只能使用-标志，因为符号对于字符串没有意义，而补 0 会改变字符串的值

指定小数精度

对于小数（浮点数），print() 还允许指定小数点后的数字位数，也即指定小数的输出精度。

精度值需要放在最小宽度之后，中间用点号.隔开；也可以不写最小宽度，只写精度。具体格式如下：

%m.nf
%.nf

m 表示最小宽度，n 表示输出精度，.是必须存在的。

强制类型转换

int(string) 将字符串转换成 int 类型；
float(string) 将字符串转换成 float 类型；
bool(string) 将字符串转换成 bool 类型。

n = int(input("请输入一个数字："))
print("输入的数字是：%d"%n)

运行结果：

运算符

算术运算符

这里拎出和c不同的运算符：

赋值运算符&比较运算符

略

逻辑运算符

三目运算符（三元运算符）

这是一种类似于其它编程语言中三目运算符? :的写法

max = a if a>b else b

如果 a>b 成立，就把 a 作为整个表达式的值，并赋给变量 max；
如果 a> b 不成立，就把 b 作为整个表达式的值，并赋给变量 max。

成员运算符

身份运算符

注意：id(x)函数用于获取对象内存地址

流程控制

条件判断语句

格式：

if 表达式 1：
    代码块 1
elif 表达式 2：
    代码块 2
else：
    代码块 3

注意：不要忘记缩进，同一代码块缩进量要相同

Python 是以缩进来标记代码块的，代码块一定要有缩进，没有缩进的不是代码块。另外，同一个代码块的缩进量要相同，缩进量不同的不属于同一个代码块。
举例：

score = 68

if score >=90 and score <=100:
    print("成绩等级为A")
elif score >= 80 and score < 90:
    print("成绩等级为B")
elif score >= 70 and score < 80:
    print("成绩等级为C")
elif score >= 60 and score < 70:
    print("成绩等级为D")
else:
    print("成绩等级为E")
print("end")

运行结果：

循环语句

if 循环语句

#默认从0开始，到5结束
for i in range(5):
    print(i)

从1开始

#从1开始，到5结束
for i in range(1,5):
    print(i)

#从0开始，到5结束，每次加2
for i in range(0,5,2):
    print(i)

name = "china"
for x in name:
    print(x,end="\t")

a = ["aa","bb","cc","dd"]
for i in range(len(a)):
    print(i,a[i])

while 循环语句

i = 0
while i<5:
    print("当前是第%d次执行循环"%(i+1))
    print("i=%d"%i)
    i+=1

break、continue和pass

• break语句可以跳出for和while的循环体
• continue语句跳过当前循环，直接进行下一轮循环
• pass是空语句，一般用做占位语句，不做任何事情
  有时候程序需要占一个位置，或者放一条语句，但又不希望这条语句做任何事情，此时就可以通过 pass 语句来实现。使用 pass 语句比使用注释更加优雅。

函数

#不带有返回值的函数
def add(a,b):
    c = a+b
    print(c)
add(11,66)

#带有返回值的函数
def add(a,b):
    return a+b
print(add(11,66))

#返回多个值的函数
def div(a,b):
    sh = a//b  #整除
    yu = a%b   #取余
    return sh,yu
sh,yu = div(11,8)
print("商：%d，余数：%d"%(sh,yu))