python基础一览表

一、基础知识

1.1、Input And Output

1.1.1 输入（input）

输入即接收用户输入的内容，函数是input()

"""
语法规则：
input("要输出的内容")
"""

input函数内用""引起来的是自定义的为了提示用户操作的文字

注：input的默认输入的为字符串类型，若想得到的数据是其他类型，需要进行数据类型转换

(参考1.2.2)

举例：接收用户输入的密码并打印，采用type()函数判断输入的是什么类型的数据

password = input("请输入你的密码：")
print(password)
print(type(password))

控制台输出结果如下：随便输入一串密码，可以看到输入的数据为字符串类型

请输入你的密码：123
123
<class 'str'>

1.1.2 输出（output）

输出即打印，函数是print()

"""
语法规则：
print(要输出的内容)
"""

（1）直接输出 

 例如：接收用户输入的密码并打印

print("你的密码是："+input("请输入你的密码"))#先输入后输出

 注：程序的运行规则为从里向外，从上到下，所以上述代码会先执行input，然后执行print

 控制台结果如下：

请输入你的密码123456
你的密码是：123456

 （2）使用占位符，后面进行赋值

        方式一：采用%进行赋值

"""
语法规则：
print(
    """
    %d
    %s
    %f
    """.%(value,value,value)
)
%d整数
%s字符串，用引号的都是字符串
%f小数，浮点数
"""

例如：

print(
    """
    编号:%s
    名字:%s
    体重:%f
    """ % (1, '周润发', 99.99)
)

         方式二：采用format进行赋值

"""
语法规则
print("...{}{}{}...".format(value,value,value))
"""

例如：

print(
    """
    编号:{}
    名字:{}
    体重:{}
    """ .format(1, '周润发', 99.99)
)

         方式三：采用f”{}“

id = 1
name = '周润发'
weight = 99.99
print(f"编号：{id}\n名字：{name}\n体重：{weight}")

1.2、数据类型

1.2.1 数据类型分类

数据类型可分为6类：

（1）整形：int

（2）浮点型：float

（3）字符串类型：str

’ ‘,” “,""" """,''' '''形式的都为字符串类型

（4）布尔类型：bool，True/1为真，False/0为假

（5）None

（6）列表、元组、字典、集合（下述详细展开）

1.2.2 数据类型转换

（1）字符串转整形int(str)

例如：input输入的类型为字符串类型，采用int(str)的方法转换成整形。

a=int(input("请输入你要转换的内容"))
print(type(a))

注：字符串必须为数字 

55
<class 'int'>

（2）浮点型转整形int(float)

f=2.16
i=int(f)
print(type(f))
print(type(i))

<class 'float'>
<class 'int'>

（3）字符串转浮点型float(str)

a = float(input("请输入你要转换的浮点数："))
print(type(a))

 注：字符串必须是数字和一个小数点的组合

请输入你要转换的浮点数：44.4
<class 'float'>

（4）整形转浮点型float(int)

i = 4
a = float(i)
print(type(i))
print(type(a))

<class 'int'>
<class 'float'>

（5）浮点型转字符串str(float)

f = 1.111
s = str(f)
print(type(f))
print(type(s))

<class 'float'>
<class 'str'>

（6）整形转字符串str(int)

i = 1
s = str(i)
print(type(i))
print(type(s))

<class 'int'>
<class 'str'>

1.3、运算符

（1）一般运算符

+，-，*，/（真除法）,//（地板除，舍去小数部分）,%（取余数）,**（幂运算）

（2）赋值运算符

常用赋值运算符是 = ，等号右边的值赋值等号左边

增强赋值运算符：+=，-=，*=，/=,%=,**=

连续赋值：a=b=c=d=10

（3）布尔运算符

== （等于），！=（不等于） >= <= > <

（4）逻辑运算符

主要有not、and和or三类，又称非、与和或
and：前后都为真则为真
or：有一个为真则为真
not:非真，非假

二、流程控制

2.1、条件分支流程

只有满足某种条件的时候才会触发 ，条件分支可以多层嵌套，分支里面套分支嘻嘻嘻

"""
语法规则：
if 布尔表达式1:
    代码块
elif 布尔表达式2:
    代码块
elif 布尔表达式3:
    代码块
    if 布尔表达式4:
        代码块
    elif 布尔表达式5:
        代码块
    ......
    else:
        代码块
    代码块
......
else:
    代码块
"""

举一个特别具有代表性的例子： 判断某位学生成绩属于什么程度，规定90-100为优秀，80-90（不包括90）为良好，70-60为合格，60以下为不合格

Score = int(input("请输入成绩："))  # 字符型转整形
if Score >= 90 and Score <= 100:
    print("优秀")
elif Score >= 80 and Score < 90:
    print("良好")
elif Score >= 60 and Score < 80:
    print("合格")
elif Score < 60 and Score >= 0:
    print("不合格")
else:
    print("你输入的成绩不符合规范")  # 异常情况判断

2.2、循环流程

多次执行代码块

2.2.1 while

"""
while 布尔表达式:
    代码块
"""

 例如：循环输入成绩，直到不在这个成绩范围内的就退出循环

while True:
    Score = int(input("请输入成绩："))  # 字符型转整形
    if Score >= 90 and Score <= 100:
        print("优秀")
    elif Score >= 80 and Score < 90:
        print("良好")
    elif Score >= 60 and Score < 80:
        print("合格")
    elif Score < 60 and Score >= 0:
        print("不合格")
    else:
        break  # 输入不符合规范的成绩就退出循环

穿插：break和continue的区别 

break：立即终止当前循环，不在执行后续操作，不在执行循环操作

continue： 跳过当前循环，不执行后续操作，继续执行循环操作

例如：

for i in range(10):
    if i == 5:
        break
    print(i)

# 输出:
# 0
# 1
# 2
# 3
# 4

for i in range(10):
    if i == 5:
        continue
    print(i)

# 输出:
# 0
# 1
# 2
# 3
# 4
# 6
# 7
# 8
# 9

2.2.2 for

"""
语法规则：
for 变量 in 可迭代对象:
    代码块
"""

例子1：对列表对象进行循环输出(列表这个玩意具体第三节再说)

lst = ['a', 'b', 'c']
for i in lst:
    print(i)


#输入
#a
#b
#c

 解析：每循环一次，列表里的一个元素就会赋值给i，直到列表里面没有任何元素，就跳出循环

for i in range(0,4):
    print(i)


#输出
#0
#1
#2
#3

for搭配range使用，这是一个经常性操作，range是一个可迭代对象，基本语法为：

range(start=0,stop,step=1)
#start值是开始下标
#stop是结束位置
#step是步长

 解析：将下标赋值给i，从下标0开始，直到4结束

三、列表（list）

列表：是将多个数据组合在一起的容器，列表是有序可变的

标识符[]

关键字list

有序是指有下标

可变是指可进行增删改查等操作

列表中的一些具体操作如下：

（1）列表翻转reverse()函数

# 列表中的操作
lst1=[1,2,3,4]
# 列表翻转reverse
# 注意注意，reverse必须先翻转在输出，如果翻转和输出一起执行的话，输出的是none
lst1.reverse()
print(lst1)

# 输出
# [4, 3, 2, 1]

（2）计算列表长度len()

lst1=[1,2,3,[1,2,3,4,[11,12,13]],6]
print(len(lst1))

# 输出
# 5

（3）列表嵌套的查询（从外到里）

lst1=[1,2,3,[1,2,3,4,[11,12,13]],6]
print(lst1[3][4][2])#先外面后里面

# 输出
# 13

（4）增加元素 append()、insert()函数

添加使用append()、insert()函数,其中append只能添加到列表末尾，insert可以根据索引插入

lst1=[1,2,3,[1,2,3,4,[11,12,13]],6]
lst1.append(1)
print(lst1)

lst1.insert(2,'dss')
print(lst1)

# 输出
# [1, 2, 3, [1, 2, 3, 4, [11, 12, 13]], 6, 1]
# [1, 2, 'dss', 3, [1, 2, 3, 4, [11, 12, 13]], 6, 1]

（5）列表合并+或extend()函数

lis1 = [1, 2, 3]
lis2 = [4, 5, 6]
print(lis1 + lis2)  # 列表拼接
lis1.extend(lis2)
print(lis1)
lis1.extend("siisi")
print(lis1)

# 输出
# [1, 2, 3, 4, 5, 6]
# [1, 2, 3, 4, 5, 6]
# [1, 2, 3, 4, 5, 6, 's', 'i', 'i', 's', 'i']

 注：使用字符串一个字符一个字符的拼接，所以数字和布尔值不能使用该方法

 （6）删除元素remove()、pop()函数

remove()函数是从前往后查找后删除，根据元素删除

pop()函数是从后往前查找后删除，可根据下标删除，也可直接删除最后一个元素

list1 = [1, 2, 'ddd', 'ddd', '4']
list1.remove('ddd')
print(list1)
# pop从后往前删,可根据下标删除
list1.pop()
print(list1)
list1.pop(1)
print(list1)

# 输出
[1, 2, 'ddd', '4']
[1, 2, 'ddd']
[1, 'ddd']

（7）修改元素，直接赋值

lis1=['11','2',3,'单独']
lis1[0]=2
print(lis1)

# 输出
# [2, '2', 3, '单独']

四、字典（directory）

字典是具有键值对映射关系的一组无序的数据组合

格式：key:value，key不变、value可以随意改变

通过key，来找到对应的value

关键字：dict

标识符：{}

注意：key是唯一的，且不能改变，通常用str

无序：没有下标/索引/index

dict = {
    "关键字": "dict",
    "标识符": "{}",
    "姓名": "ldh",
    "列表": [1, 2, 3, [4, 5, 6]],
    "年龄": 18,
    "是否美丽": True
}

# print(dict)

# 新增：字典的变量名{"字典中不存在的key"}=值 --向字典中添加一组键值对
# 修改：字典的变量名{”字典中存在的key“}=值 --把原有字典的value换成新的


dict['age'] = 18
print(dict)
dict['年龄'] = 8
print(dict)
dict["列表"][1] = 10
print(dict)

# 删除pop(key)，key不允许为空
# popitem从后向前删除
# clear()全部清除
dict.pop('标识符')
print(dict)

# 输出
# {'关键字': 'dict', '标识符': '{}', '姓名': 'ldh', '列表': [1, 2, 3, [4, 5, 6]], '年龄': 18, '是否美丽': True, 'age': 18}
# {'关键字': 'dict', '标识符': '{}', '姓名': 'ldh', '列表': [1, 2, 3, [4, 5, 6]], '年龄': # 8, '是否美丽': True, 'age': 18}
# {'关键字': 'dict', '标识符': '{}', '姓名': 'ldh', '列表': [1, 10, 3, [4, 5, 6]], '年龄': 8, '是否美丽': True, 'age': 18}
# {'关键字': 'dict', '姓名': 'ldh', '列表': [1, 10, 3, [4, 5, 6]], '年龄': 8, '是否美丽': True, 'age': 18}

五、元组（tuple）

1.有序的 --索引/下标/index[正序，反序]
2.标识符（） --里面的元素用逗号分隔开来，和列表相似
3.关键字：tuple

元组简单 --只能查询，不能增删改
查询：元组的变量名[下标]
元组需要修改时，需要先把他的类型转换为列表,修改后再转换回来

注：（）有很多方式都能使用，所以一个元素也要用逗号隔开

常见面试题：
1.元组与列表的区别
元组不可变 --程序运行的时候无法改变（没有提供这些可操作的方法去改变）

2.元组既然是不可变的，那么存在的意义是什么？
出于安全性考虑  --不需要改变的内容可以使用元组
任何可以变化的数据都有可能造成我们的安全性问题，这个时候不变的数据采用元组，可以保证其安全性

六、集合

集合 -- 由不同的元素组成的一个数据结构（无序排列）
标识符：{}
集合内的元素，不能重复，集合和集合之间可以做运算
关键字：set

# 自动去重
set2={'hh','hh',1,2,3,4}
print(set2)

#输出
{'hh', 3, '22', 4}

操作：增删改查,与列表一致，但是对于任何操作都是无序进行的
查询 --需要先转换再查询

"""
集合用来做多组数据的逻辑运算
"""
set1 = {"11", "sisi"}
set2 = {"11", "cc"}
# 交集：两个集合中的相同数据
print("交集", set1.intersection(set2))
# 并集：合并【重复去除】
print("并集", set1.union(set2))
# 差集：把自己有，对方没有的元素获取
set3 = {1, 2, 3, 4, 5}
set4 = {1, 2, 3, 6, 7}
print("差集：", set3.difference(set4))

# 交叉补集：公有部分全部移除掉，只留下独有部分

print("交叉补集", set1.symmetric_difference(set2))

七、pycharm常用快捷键操作

（1）格式化代码（***）：

Ctrl+Alt+l

（2）快速换行：

Shift+Enter

（3）快速复制光标所在行的代码：

Ctrl+d

（4）快速执行

Alt + Shift + F10

有问题也欢迎大家批评指正~~~~