Python基础知识汇总【1】

〇、基本配置和理解

python3.5＋

注：学习python开始不要总想为什么，什么原理，这样会陷入误区，重点在能够运用，编程思想和底层原理到后面都会有解释的

前置理解（我也不知道放在哪里讲合适）：

• 注释包括：

  • # 行注释

  • ‘’’ 块注
    释’‘’

• 运行方式：

  • 交互运行（cmd）：运行速度快，但代码不能修改，一次性的，写错了前面的都白写了（后面小块代码就用交互模式运行）
  • 脚本模式：先找个txt本，统一编辑，然后改文件后缀成py，再运行（大块代码我就用这种方法）
  • 上面两个结合：txt->py后，在cmd中输入文件位置就可以运行了

• python代码块的区分使用统一缩进，不用”{ }“，语句不用“;”结尾

  • class:
        _init_():
            ......
        def func1():
            ......
        def func2():
            return
    
    def func3():
        ......
        if():
            ......
        else:
            ......
    
    if _name_ == "main":
        ......
        
    

• 编码格式基本都是utf-8，如果是格式出现错误就在代码最前面写

  • # – coding: utf-8 –

• 代码尽量短小写，编译器不同可能会不识别（除了URL和地址和模块）

• 输入输出print(), input()

  • input里包含一个print（无需再写print），即：

  • a = input("输入:")# 不像C语言的scanf，input()不能用占位符，a也不用提前声明，emmm怎么说呢，你先尽量理解，后面解释
    print(a)
    输入:UUU
    UUU
    

• 条件语句：

  • if condition_1:
        statement_block_1
    elif condition_2:
        statement_block_2
    else:
        statement_block_3
    

  • 没有switch-case，但有match-case(原理相同)

• 循环语句

  • while condition:
    	statements
    

  • for variable in sequence:# 半个条件语句，一般不加else
        statements
    '''else:
        	<statements>'''
    

  • sequence快速构建函数range(起始， 结束， 步幅)或者range(个数)

  • print(range(10))# 实则range(0,10)
    for i in range(0,10):
    	print(i)# 1~9有头无尾
    for j in range(3, 10, 2):
        print(j)# 3 5 7 9
    for n in range(18, 3, -3):
        print(n)# 18 15 12 9 6
    

• break,continue和C一样

一、基本数据类型

• Number（数字）

  • 各种子类：整型int，浮点型float，布尔值bool（True / False对应1/0），复数complex（不会用）
  • 也有其他类型比如short，long（python3就大一统成int了，知道这能存储整数就好）

• String（字符串）

  • 用引号引起来的，比如 “biuahbfiuah”, ‘哈哈哈哈’

• List（列表）

  • 列表用[ ]来表示,[ ]中可放字符、字符串、数字或是嵌套列表，比如：

    list1 = [1, 2, 3, 4]
    list2 = [‘shsh’, 3, “哈哈哈”, list1, 0.9]

  • python里列表就是万能工具（相当于数组）

• Tuple（元组）

  • 元组使用()来表示,()中可放字符、字符串、数字或是嵌套元组（不能修改值的列表）（只有一个元素时要在后面加逗号，Tup = （“哈哈哈”，）多元素时不用在意）

• Set（集合）

  • 集合使用set()或{ }来表示,set()中可放字符、字符串、数字或是嵌套元组

• Dictionary（字典）

  • 字典是一种映射类型，字典用 { } ，它是一个无序的键(key) : 值(value)的集合（key是不可变类型，在同一个字典中，key必须是唯一的，一般是字符串）
  • 格式Dict = {“key1”: “value1”, “key2”: “value2”}

发现tup， list， set有亿点点像啊~所以他们之间部分可以相互转换（再加一个string凑够4个）

数据类型转换：

>>> list1 = [1, 2, 3, 4]
>>> set1 = set(list1)# 显式转换
>>> print(set1)# 其他的都类似，如list(x),tuple(x),str(x),float(x),bool(x) 
{1, 2, 3, 4}

>>> a=12
>>> b=1.3
>>> print(a+b)//隐式转换
13.3

• 不可变数据类型（不可修改）：num, str, tuple
• 可变数据类型：list, dict, set
• string、list 和 tuple 都属于序列（应用方法差不多）

二、数据类型基本操作

内置函数type(xxx)可以看数据的类型（精确到子类）

格式化：

• 占位符：%d十进制整数（%o%b%x），%f浮点（默认保留到后六位，%.1f保留一位，%6f整数部分保留六位），%s字符串，%e科学计数法

    >>> a = 2
    >>> b = 3.354683
    >>> print("xxx%dx%.2fxxx"%(a, b))
    xxx2x3.35xxx

• format()

   >>> university = "ABC"
   >>> location = "HHHHH"
   >>> print("哈哈{}哈哈哈{}哈哈".format(university, location))
   哈哈AHU哈哈哈Hefei哈哈
  

• f-string(最人性化)

   >>> major = "IC"
   >>> select = "IT"
   >>> print(f"My major is {major} and my elective course is {select}.")
   My major is IC and my elective course is IT.
  

1, Number

1.1 类型

主要是整型和浮点型(8位双精度)

1.1.1 整型

以0b,0o,0x开头分别是二进制，八进制，十六进制

将十进制转化为其他进制的内置函数：bin(), oct(), hex()

>>> a = 6
>>> b = 4
>>> print(id(a), id(b))
2988064113040 2988064112976
>>> c = a
>>> print(id(c))# 和a的地址一样！
2988064113040
>>> a = 1
>>> print(id(a))# 地址改变！
2988064112880

注意python是面向对象的语言，时刻记着对象的概念

数字是Python中的不可变对象，当改变它的值时，并不是真的修改内存中变量的值，而是把新的值放入内存中，然后修改变量，使得变量指向新值的内存地址。浮点数、复数等其他数字类型及其他类型的变量具有同样的特点。

\# 进制转换 datatype(num/variable, base=进制)
>>> a = 56
>>> print(int(a, 8))# 这是错的
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: int() can't convert non-string with explicit base
# int是个类（之后说）

>>> int('5')   # 等价于int('5',10)，将字符串5,转化成10进制int
5
>>> int(5)  # int(5,10)  将数字5 转化成10进制int， base=10默认
5
>>> int('5',2)  # 代表字符串'5' 为2进制，转化成10进制，但是二进制中只有0和1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 2: '5'
>>> int('5',10)
5
>>> int(5,2)    # 其实需要注意的是，除了十进制是数字以外，python中其他的进制都是字符串
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: int() can't convert non-string with explicit base
>>> int('101',2)
5

# 因此，原式：
>>> a = 56
>>> print(int(str(a), 8))
46

>>> type(bin(5))# 除了十进制，其他进制的强制转换都是字符串类型
<class 'str'>
>>> type(hex(5))
<class 'str'>

1.1.2 浮点数

Python中的浮点型是双精度的，对于很大或者很小的浮点型，可以使用科学计数法表示，比如：

1.2e-2 = 0.012

1.1.3 布尔

• Python中的布尔类型只有True和False两个取值；
• True对应整数1，False对应整数0。
• 常用的布尔运算包括 and、or、not 三种

等同于False的值：

• None；
• False；
• 任何为0的数字类型，如0、0.0、0j；
• 任何空序列，如’‘’'、()、[]；
• 空字典，如{}；
• 用户定义的类实例，如类中定义了__bool__()或者__len__()方法，并且该方法返回0或者布尔值False。

等同于True的值：

• 非零数值
• 非空字符串

和C的&&，||差不多

>>> a = 1
>>> b = 2
>>> print(a and b, a or b, not a)# a and b，如果a是False，则整个结果必定为False，因此返回a的值，如果a是True，则表达式的结果取决于b,因此返回b;not是单目
2 1 False

1.2 运算

大体和C语言一样，多了 ** 幂运算，// 整除（商的整数部分，向下取整）

还有内置函数和那些数学库（和cmath.h差不多，后面说）

2, String

2.1 初始化

# 引号初始化
str1 = 'hello world'
str2 = "hello python"
str3 = '''hello code'''
str4 = "she says:'OMG!'"# 字符串中有引号：内外层引号不同或使用转义字符\"
# 字符串换行
str5 = "hello world\
		hello world\
		hello world."# 使用转移换行符

2.2 字符串的转义字符:

如要单独输出双引号,则应使用\""代替
\''   -->表示转义单引号
\""   -->表示转义双引号
\n    -->表示换行
\t    -->表示制表符
\r	  -->光标移至开头
\\	  -->反斜杠，地址经常用

2.3 字符串编码

# py3.x常用Unicode编码
# encode() 编码
str.encode('utf-8') --> 以UTF-8格式对字符串str进行编码
# decode() 解码
str.decode('gbk') --> 以GBK格式对字符串str进行解码
# chr() 将ascii码值转换为对应的字符
chr(97) # a
# ord() 将字符转换为对应的ascii码值（py2.x不能用）
ord('a') # 97
# bytes() 字节串
b1 = bytes() # 空字节串
b2 = b'' # 通过b前缀将字符串转化为byte
# 方法
b3 = bytes('Hello', encoding='UTF-8')

2.4 操作

# 下标(索引)，从零开始
str = "hello world"
print(str[4]) # o
# 切片 str[开始:结束:步长]，范围：左闭右开
print(str[1:10:2]) # el ol(中间有空格)

# 字符串长度len()
len(str)

# 字符串的大小写转换
str1.upper() # 将字母转换为大写字母
str2.lower() # 将字母转换为小写字母
str3.swapcase() # 将大小写转换
str4.title() # 首字母大写

# 统计子串出现的次数count()
str.count(str1)

# 查找字符串出现的位置
str.find("str1")# 查找子串在字符串中第一次出现的位置
str.find("x",start.end)# 在指定范围内查找，若未找到不报错，返回-1
index() # 若未找到即报错
rfind() # 查找子串在字符串中最后一次出现的位置。若找到，返回下标，否则返回-1。
rindex() # 和rfind()功能类似，区别是若未找到即报错。

# 字符串的提取
strip() 去除字符串两边的指定字符，默认为空格 例如: str.strip("x") -->去除str两边的x
lstrip() 只去除字符串左边的指定字符 rstrip() 只去除字符串右边的指定字符

# 字符串的分割和合并
str.split("指定字符") # 指定字符默认为空格
"指定字符".join(str) # 合并字符串 

# 字符串的替换和判断:
replace("old_str", "new_str", "num") # 将字符串中的指定内容进行替换 num:替换的次数
# str.method 返回值为布尔型(True/False)
isupper() # 检测字母是否全为大写
islower() # 字母是否全为小写
isdigit() # 是否只由数字组成
isTitle() # 首字母是否全为大写
isalpha() # 是否全为同一类字符组成

3，List

列表是最常用的 Python 数据类型，如下所示：

list1 = [1, 2, 3, 4, 5]
list2 = ['a', 'b', 'c']
list3 = [1, 2, 'a', 'b']

3.1 初始化

创建空列表：

>>> list_a = []
>>> print(list_a)
[]

指定元素-直接初始化：

>>> list_b = [1, 2, 'a', 'b']
>>> print(list_b)
[1, 2, 'a', 'b']

字符串-间接初始化:

>>> list_c = list(string)
>>> print(list_c)
['a', 'b', 'c', 'd', 'e', 'f', 'g']

元组初始化-类型转换:

>>> tuple = (1, 2, 'a', 'b')
>>> list_d = list(tuple)
>>> print(list_d)
[1, 2, 'a', 'b']

推导式(更高效):

列表推导式格式为：
[表达式 for 变量 in 列表]
[out_exp_res for out_exp in input_list]

>>> list_e = [i for i in range(10)] # list(range()) 也可视作列表
>>> print(list_e)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

或者
[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]

>>> multiples = [i for i in range(30) if i % 3 == 0]
>>> print(multiples)
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

其中 out_exp_res为元素表达式

>>> names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
>>> new_names = [name.upper()for name in names if len(name)>3]
>>> print(new_names)
['ALICE', 'JERRY', 'WENDY', 'SMITH']

循环添加,重复运算符(最快):

# for循环
list_f = []
for i in range(10):
    list_f.append(1)
print(list_f)  # [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] 

# while循环
list_g = []
i = 0
while i < 10:
    list_g.append(2)
    i += 1
print(list_g)  # [2, 2, 2, 2, 2, 2, 2, 2, 2, 2]

# 重复运算符*
list_h = [0]
print(list_h * 10)  # [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

3.2 访问

访问单个元素-索引（index：下标、索引）
列表索引从 0 开始，第二个索引是 1，依此类推。
遍历-for循环

for i in list: #遍历列表

for i,v in enumerate(list): #同时遍历列表的元素及其下标
	......

3.3 操作

截取，拼接，组合，重复，列表比较与字符串的操作差不多
注意有无返回值

1 len(list)
列表元素个数
2 max(list)
返回列表元素最大值
3 min(list)
返回列表元素最小值
4 list(seq)
将元组或字符串转换为列表

方法(直接修改列表则无返回值):

father_list = []
for i in range(12):
    build_in_list = [1, 2, 3, 4, 5]
    father_list.append(build_in_list)
print(father_list)  # [[1, 2, 3, 4, 5], ...共11个列表..., [1, 2, 3, 4, 5]], 嵌套列表

father_list[0].append(5)
print('1.在列表末尾添加新的对象list.append(obj):\n\tfather_list[0].append[5] =', father_list[0])

print('2.统计某个元素在列表中出现的次数list.count(obj):\n\tfather_list[1].count(3) =', father_list[1].count(3))
father_list[2].extend(father_list[0])
print('3.在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）'
      'list.extend(seq):\n\tfather_list[2].extend(father_list[0]) =', father_list[2])
print('4.从列表中找出某个值第一个匹配项的索引位置list.index(obj):\n\tfather_list[3].index(4) =',
      father_list[0].index(4))
father_list[4].insert(2, 4)
print('5.将对象插入列表list.insert(index, obj):\n\tfather_list[4].insert(2, 4) = ', father_list[4])
return_value = father_list[5].pop()
print('6.移除列表中的一个元素（默认最后一个元素），并且返回该元素的值'
      'list.pop([index=-1]):\n\tfather_list[5].pop() = ', father_list[5], '\n\t返回:', return_value)
father_list[6].remove(3)
print('7.移除列表中某个值的第一个匹配项list.remove(obj):\n\tfather_list[6].remove(3) = ', father_list[6])
father_list[7].reverse()
print('8.反向列表中元素list.reverse():\n\tfather_list[7].reverse() = ', father_list[7])
list_in_9 = [4, 3, 7, 2, 7, 5, 6, 9, 4]
list_in_9.sort()
list_in_9.sort(reverse=True)
print('9.对原列表进行排序list.sort( key=None, reverse=False):\n\tlist_in_9.sort() = ', list_in_9,
      '\n\tlist_in_9.sort(reverse = True)', list_in_9)
father_list[10].clear()
print('10.清空列表list.clear():\n\tfather_list[10].clear() =', father_list[10])
list11 = father_list[11].copy()
print('11.复制列表list.copy():\n\tfather_list[11].copy() =', list11)

输出:

1.在列表末尾添加新的对象list.append(obj):
	father_list[0].append[5] = [1, 2, 3, 4, 5, 5]
2.统计某个元素在列表中出现的次数list.count(obj):
	father_list[1].count(3) = 1
3.在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）list.extend(seq):
	father_list[2].extend(father_list[0]) = [1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 5]
4.从列表中找出某个值第一个匹配项的索引位置list.index(obj):
	father_list[3].index(4) = 3
5.将对象插入列表list.insert(index, obj):
	father_list[4].insert(2, 4) =  [1, 2, 4, 3, 4, 5]
6.移除列表中的一个元素（默认最后一个元素），并且返回该元素的值list.pop([index=-1]):
	father_list[5].pop() =  [1, 2, 3, 4] 
	返回: 5
7.移除列表中某个值的第一个匹配项list.remove(obj):
	father_list[6].remove(3) =  [1, 2, 4, 5]
8.反向列表中元素list.reverse():
	father_list[7].reverse() =  [5, 4, 3, 2, 1]
9.对原列表进行排序list.sort( key=None, reverse=False):
	list_in_9.sort() =  [9, 7, 7, 6, 5, 4, 4, 3, 2] 
	list_in_9.sort(reverse = True) [9, 7, 7, 6, 5, 4, 4, 3, 2]
10.清空列表list.clear():
	father_list[10].clear() = []
11.复制列表list.copy():
	father_list[11].copy() = [1, 2, 3, 4, 5]

赋值（“=”）：即为传引用a 和 b 都指向同一个对象。

浅拷贝（“copy”）：a 和 b 是一个独立的对象，但他们的子对象（嵌套）还是指向同一个对象

深拷贝（“deepcopy”）：a 和 b 及他们的嵌套子对象都相互独立（需要import copy；syntax：copy.deepcopy(list)）

reverse: 是否是倒序. True: 倒序, False: 正序

4，Tuple

不可修改的列表，不更改操作与列表一样

t = (666, True, '漫威')# 定义元组
print(t)# 打印元组
print(t[0])# 获取元组中的元素
for i in t:# 遍历元组中的值
    print(i)
# 重新给元组赋值
# t[2] = 'DC'  # TypeError

5，Dict

5.1 初始化

dict1 = {}# 空字典
dict2 = {"name": "张三", "age": 20, "sex": "男"}（一般格式，key不能重复不可改变，否则会覆盖）
dict3 = {num: num ** 2 for num in range(1, 10)}# 看列表的推导式语法
# dict3 = {1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
dict4 = dict(zip(['a', 'b', 'c'], '123'))# zip压缩，很形象~
# dict4 = {'a': '1', 'b': '2', 'c': '3'}
dict5 = dict(one=1, two=2, three=3, four=4)# 字典构造器
# dict5 = {'one': 1, 'two': 2, 'three': 3, 'four': 4}

5.2 访问(遍历)

dict2 = {"name": "张三", "age": 20, "sex": "男"}
# 直接访问key（类似于list和str直接访问index）
print(dict2["age"])# 20
如果key值存在,那么返回对应字典的value,不会用到自己设置的value;
如果key值不存在.返回None,并且把新设置的key和value保存在字典中;
如果key值不存在,但设置了value,则返回设置的value;
字典名.setdefault(key[,value])
字典名.get(key[,value])————来自百度（主要用来检查字典）
# 返回所有key或value（记着：字典也是个类）
print(dict2.keys())# 别忘了-s，调了好久才发现！baga
print(dict2.values())
# 返回包含(键值,实值)元组的列表
print(dict2.items())# 视图对象
# 遍历key
for key in dict2:# key可以用任何代替，字典默认遍历对象就是key
    print(key)
for key in dict2:
    print(f'{key}: {dict2[key]}')
for i in my_dict.items():
    print(i)
for i in enumerate(dict2):
    print(i)

5.3 操作

dict2 = {"name": "张三", "age": 20, "sex": "男"}
更新
dict2["name"] = "罗老师"
删除
del dict2["sex"]
增加
dict2["address"] = "合肥"
输出
str(dict2)# 神奇吧，竟然是str
合并
dict2.update(other_dict)
新建
>>> dict2 = {"name": "张三", "age": 20, "sex": "男"}
>>> dict2.fromkeys(dict2, "可选参数")
{'name': '可选参数', 'age': '可选参数', 'sex': '可选参数'}
还有clear(), popitem(), copy(), len()等等和list一样

frozenset() 创建一个冻结的集合，冻结的集合不能进行添加和删除操作。

6，Set

集合的元素，其基本数据类型是不可变数据类型（list、dict、set就不可作为集合的元素）（集合可变，其数据类型不可变）

6.1 初始化

与 list 的相同（推导式构造器等全都通用），但声明有两种：

t1 = set()
t2 = {}

6.2 操作

同list的

• 添加（add，update，append）

• 删除{remove，pop（随机干掉一个），dicard（不存在不报错），del（这个只能是删除整个集合，因为集合不支持索引，再打印就报错；删除后copy副本不受影响），clear（清空，在打印不报错）}

• 遍历（那几种）

• 去重（集合自带去重的属性，把其他类型变成集合再变回去就能去重了）

    l = ['a','a','c','b','e','d','d','f']
    nl = list(set(l))
    print(nl) # ['f', 'c', 'd', 'b', 'a', 'e']，顺序跟set()有关，会时刻变化；要想原顺序就用遍历

    import itertools# 重新排序
    
    l = [1,4,3,3,4,2,3,4,5,6,1]
    l.sort()
    sl = itertools.groupby(l)
    print(sl) # <itertools.groupby object at 0x000001D44000D588>
    for k,obj in sl:
        print(k)
    """输出
    a
    b
    c
    d
    e
    f
    """

6.3 运算

这才是集合真正的用途：

set1 = {1, 4, 7, 2, 9, 3}
set2 = {2, 3, 4, 5, 6, 7, 8, 9}

# 并集
print(set1 | set2)
print(set1.union(set2))
{1, 2, 3, 4, 5, 6, 7, 8, 9}
# 交集
print(set2 & set1)
print(set1.intersection(set2))
{2, 3, 4, 7, 9}
# 差集
print(set2.difference(set1))
print(set2 - set1)
{8, 5, 6}
# 反差集
print(set1.symmetric_difference(set2))
print(set1 ^ set2)
{1, 5, 6, 8}

# 成员运算符in，not in
print(1 in set2)
False

# 子集，超集< > <= >= == != <>
set3 = {i for i in range(20)}
print(set1.issubset(set3))
print(set1 < set3)
True
print(set3.issuperset(set1))
print(set3 > set1)
True

冻结集合frosenset()

三、内置函数

共68个，前面已经介绍了不少了，现在补充（认识就好）：

数学运算

print(abs(-2))  # 绝对值:2
print(divmod(20,3)) # 求商和余数:(6,2)
print(round(4.50)) # 五舍六入:4
print(round(4.51)) # 四舍五入:5，python的四舍五入有点非人类，尽量别用（你可以去网上搜搜），整除1可以代替此方法
print(pow(10,2))# 幂:10**2
print(pow(10,2,3))  # 给了第三个参数. 表示最后取余:1
print(sum([1,2,3,4,5,6,7,8,9,10]))  # 求和:55
print(min(5,3,9,12,7,2))  #求最小值:2，可以传列表，元组
print(max(7,3,15,9,4,13))  #求最大值:15

容器修改

old_list = "Anhui University" 
print(list(reversed(old_list))) 
# 倒序['y', 't', 'i', 's', 'r', 'e', 'v', 'i', 'n', 'U', ' ', 'i', 'u', 'h', 'n', 'A']

s = slice(1, 7, 2)  # 切片（无序的不支持索引和切片）
print(old_list[s])  # nu 

print(all([1,'hello',True,9]))  #可迭代对象中全部是True, 结果才是True(大and):True
print(any([0,0,0,False,1,'good']))  #可迭代对象中有一个是True, 结果就是True(大or):True

迭代器生成器字符串

zip(), map(), filter(), range(), next() ,iter(), compile() , exec(), eval()，hash（）

locals(), globals()