python基础知识总结

1、python工作原理

python源代码（.py格式）先编译为字节码（.pyc格式），编译好的字节码转发到虚拟机（PVM）中执行

2、python注释

单行注释 #

# 这是单行注释

多行注释''' '''（三个单引号）或者""" """（三个双引号）

'''
单引号多行注释
这是第一行注释
这是第二行注释
'''
"""
双引号多行注释
这是第一行注释
这是第二行注释
"""

快捷注释 ctrl+/

3、print函数

print()是python内置函数，可以输出数字，字符串，布尔，列表，元组，字典，集合等

# 输出引号中内容
print('Hello World!')

# 输出多个参数，参数值之间用逗号隔开
print(1,  [1, 2], 'Hello World!')

# 如果想要在一行输出，可以加end参数
print('Hello World!', end=' ')

4、常量和变量

常量：在程序的执行过程中其值一直不变的量，S=PI*r*r,(这个里面不变 的是PI，这个就是常量)

变量：在程序执行过程中其值可以改变的量，变量的本质其实是一块内存空间。当我们把一个值赋给一个名字时，它会存储在内存中，这块内存就是变量。

Python中变量可以不声明，但是使用前必须先赋值，变量在赋值的那一刻被创建。

5、标识符与关键字

  规则：由数字，字母，下划线组成并且不能以数字开头，并且不能是关键字。

  函数名和变量都属于标识符

  关键字是特殊的标识符，是python自定义的不允许开发者定义的标识符，python有33个关键字。

在命令行查看关键字help("keywords")

6、input（）

input（）是python中最基本的输入方法，通常用于接收用户的输入默认类型是字符串。

# 变量 = input（’提示信息‘）
user_name = input('请输入用户名！')

7、python数据类型

 Python标准数据类型共6种：

1. 数字类型（number）
2. 字符串（string）
3. 列表（list）
4. 元组（tuple）
5. 字典（dict）
6. 集合（set）

可变类型：列表，字典，可变集合

不可变类型：数字类型，字符串，元组，不可变集合

8、数字类型（number）

Python3.X支持4种数字类型：

  Int：整型

通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。布尔(bool)是整型的子类型。

  Float：浮点型

浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）

  Bool：布尔型

布尔型，对于数字只有0和1，对于逻辑，有True和False（在很多语言中，0表示假，除0之外都是真）

  Complex：复数

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

# Type（）用于判断不同的数字类型
a = 2  # <class 'int'>
b = 1.25  # <class 'float'>
c = True  # <class 'bool'>
d = complex(1.0, 2)  # <class 'complex'>
print(type(d))

1）python数字类型转换

不同的数字类型转换

# Int（）转为整型
# Float（）转为浮点数
# bool（）转为字符串
a = 2
a = bool(a)  # 转为True
a = float(a)  # 转为1.0
b = 2.75
b = int(b)  # 转为2，舍弃小数部分

2）python运算符

+  -  *  /  %（取余或者求模）//（取整数）  **（乘方）

3）复合运算

c = c + a 以简化为 c + = a

其余运算符使用方法类似

4）比较运算符

<  >  ==  <=  >=  !=

5）逻辑运算符

逻辑与：and

逻辑或：or

逻辑非：not

逻辑与：x and y

如果x为假，则直接输出x

如果x为真，则继续判断并输出y

逻辑或：x or y

如果x为真，则直接输出x

如果x为假：则继续判断并输出y

逻辑非：表示不是

6）成员运算符

in：如果在指定的序列中找到成员则返回True，否则返回False

not in：如果在指定的序列中没有找到返回True，否则返回False

7）python的运算符优先级

算术运算符>关系运算符>赋值运算符>成员运算符>逻辑运算符（（）>not>and>or）

9、字符串（string）

字符串是一种表示文本的数据类型，有三种表示方法

# 单引号’  ‘表示字符串
# 双引号”  “表示字符串
# 三引号’’’  ‘’’ “””  “””表示字符串
# 引号中不能包含自己，单引号和双引号只能有一行，三引号可以包含多行
s1 = 'abc'
s2 = "abc"
s3 = '''
用于输入"多行"字符
'''

1）转义字符

在需要在字符中使用特殊字符时，python 用反斜杠 \ 转义字符

常用的转义字符以及含义：

\转义   \b 退格   \n换行   \f 换页    \v 纵向制表符    \t 横向制表符

2）字符串输出

format（）格式化输出

Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。

把字符串当作模板，通过传入参数实现格式化

print('{}*{}={}'.format(2, 3, 6))  # 2*3=6

# 第一部分：{}是给定的格式，可以在前后插入内容
# 第二部分：format（）函数
# 第三部分：括号为要输出内容

f-string格式化输出

f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法。

print(f'{2}*{3}={6}')  # 2*3=6
# f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去

3）索引

索引，也称为下标，并且索引从0开始，从末尾的位置从-1开始，可以通过索引访问字符串中指定值

s = 'abc'
print(s[0])  # 输出字符串第一个字符
print(s[-1])  # 输出字符串最后一个字符

4）切片

切片用于截取字符串一部分长度的字符

string[起始：结束：步长]，缺省起始值，默认从第一个字符开始；缺省结束值，默认最后一个字符结束；缺省步长，默认步长为1

注意起始与结束前开后闭

s = 'abcdef'
# string[起始：结束：步长]
print(s[1:5:2])  # bd，从第二个字符开始，从第六个字符结束，每次间隔2个字符取值
print(s[:2])  # ab，缺省起始值，默认从第一个字符开始
print(s[2:])  # cdef，缺省结束值，默认从最后一个字符结束
print(s[5:1:-1])  # fedc，从第六个字符开始，从第二个字符结束，逆序输出字符

5）字符串中的运算符

+  *  in  not in  ==  is

==：判断字符串是否相等，返回bool类型，true或者false

is：除了判断值是否相等，还判断字符串的地址，返回bool型

6）字符串内建函数

s = 'abcdef'
'''
（1）find()-检查字符串中是否包含指定的子字符串，如果包含则返回索引值，否则返回-1
格式：str.find(str1,start,end)
Str:指定检索的字符串（在哪里找）
Str1：要找的子字符串（找什么）
Start:开始索引,可以省略
End：结束索引，可以省略
'''
print(s.find('a'))  # 0

'''
（2）count()-用于统计某个子字符串出现的次数
格式：str.count(str1,start,end)
Str:指定检索的字符串（在哪里找）
Str1：要统计的子字符串（要统计什么）
Start:开始索引值
End：结束索引值
'''
print(s.count('a'))  # 1

'''
（3）replace()-该函数可以将旧的子字符串替换为新的
格式：str.replace(old,new,mac)
Str:替换的字符串
Old：被替换的子字符串
New：替换后的新字符串
Mac：替换次数
'''
print(s.replace('a', 's'))  # sbcdef

'''
（4）split()-该函数可以通过指定的分隔符对字符串进行分割
格式：str.split(str1,num)
Str:要分割的字符串
Str1：分隔符，默认是空格
Num:分割次数
'''
print(s.split('c'))  # ['ab', 'def']

Split()函数与字符串的切片有什么区别？
1）切片是使用索引来分割，split()函数使用分隔符来分割
2）切片返回的是子字符串，split（）函数返回的是列表

'''
（5）index()-该函数和find()函数基本一样，但是如果在某一区间没有找到该子字符串的时候，不再返回-1，而是直接报错
'''
print(s.index('c'))  # 2

'''
（6）isalnum()-该函数判断字符串的组成，如果字符串是有数字或者字母组成则返回true，否则返回false
（7）isalpha()-该函数判断字符串组成，全是字母组成则返回true，否则返回false
（8）isdigit()-该函数判断字符串组成，字符串全是有数字组成则返回true，否则返回false
'''
print(s.isalnum())  # True
print(s.isalpha())  # True
print(s.isdigit())  # False

'''
（9）strip()-默认去掉字符串首尾的空格或者换行符
'''

'''
（10）capitalize()-第一个字母大写，其余小写
（11）title()-单词的首字母大写，其余小写
（12）upper()-全部大写
（13）lower()-全部小写
'''
print(s.capitalize())  # Abcdef
print(s.title())  # Abcdef
print(s.upper())  # ABCDEF
print(s.lower())  # abcdef

10、列表（list）

列表是任意对象的集合，列表可以存放任意类型的数据，而且数据之间没有任何关系。列表用[]表示

列表有序也有索引，索引也是从0开始

1）索引

与字符串索引类似

l = ['red', 'blue', 'yellow', 'green', 'pink', 'brown']
print(l[0])  # red

2）切片

与字符串切片类似

l = ['red', 'blue', 'yellow', 'green', 'pink', 'brown']
# list[起始：结束：步长]
print(l[1:5:2])  # ['blue', 'green']，从第二个元素开始，从第六个元素结束，每次间隔2个元素取值
print(l[:2])  # ['red', 'blue']，缺省起始值，默认从第一个元素开始
print(l[3:])  # ['green', 'pink', 'brown']，缺省结束值，默认从最后一个元素结束
print(l[5:3:-1])  # ['brown', 'pink']，从第六个字符开始，从第二个字符结束，逆序输出列表

3）向列表中增加元素

l = ['red', 'blue']
l1 = ['a', 'b']
# append（）-加到末端，可以是任意类型的元素，字符串，数字，列表
# list_1.append（’元素’）
l.append('yellow')  # ['red', 'blue', 'yellow']

# insert（）-在指定的索引位置处增加
# list_1.insert（1,’元素’）
l.insert(1, 'green')  # ['red', 'green', 'blue', 'yellow']

# extend（）-extend把一个列表增加到另一个列表中（无缝增加）
# list_1.insert（1,"元素"）
l.extend(l1)  # ['red', 'green', 'blue', 'yellow', 'a', 'b']

4）删除列表元素

l = ['red', 'blue', 'yellow', 'green', 'pink', 'brown']
# pop（）-删除列表中最后一个元素，默认删除最后一个，并返回该元素
print(l.pop())  # brown

# remove（）-删除列表中给定的对象
list_1.remove（‘元素’）
l.remove('red')
print(l)  # ['blue', 'yellow', 'green', 'pink']

# del是一个方法，不是一个函数
del l[0]
print(l)  # ['yellow', 'green', 'pink']

# clear（）清空
l.clear（）

5）列表赋值和拷贝

浅拷贝复制指向某个对象的地址（指针），而不复制对象本身，新对象和原对象共享同一内存。

深拷贝会额外创建一个新的对象，新对象跟原对象并不共享内存，修改新对象不会影响到原对象。

赋值其实就是引用了原对象。两者指向同一内存，两个对象是联动的，无论哪个对象发生改变都会影响到另一个。

import copy
l1 = ['a', ['b', 'c'], 'd']
l2 = l1  # 赋值，对复制的列表进行修改操作会影响原列表，无法恢复。
l2[1][0] = 's'
print(l1, l2)  # ['a', ['s', 'c'], 'd'] ['a', ['s', 'c'], 'd']
l3 = l1.copy()  # 浅拷贝，对复制的列表进行修改操作会影响原列表，无法恢复。
l2[1][0] = 'r'
print(l1, l3)  # ['a', ['r', 'c'], 'd'] ['a', ['r', 'c'], 'd']
l4 = copy.deepcopy(l1)  # 深拷贝，对复制的列表进行修改操作不会影响原列表
l2[1][0] = 't'
print(l1, l4)  # ['a', ['t', 'c'], 'd'] ['a', ['r', 'c'], 'd']

6）修改列表元素

# list_1[索引]=新元素
l = ['red', 'blue', 'yellow']
l[0] = 'a'
print(l)  # ['a', 'blue', 'yellow']

7）列表常用方法和函数

l = [2, 5, 4, 3, 1]
# list_1.sort（）默认是从小到大排序
l.sort()
print(l)  # [1, 2, 3, 4, 5]
l.sort(reverse=True)  # 增加参数，从大到小排序
print(l)  # [5, 4, 3, 2, 1]
# list_1.reverse（）将列表逆置
l.reverse()
print(l)  # [1, 2, 3, 4, 5]
# len（）列表元素数量
print(len(l))  # 5
# max（）列表中最大值

11、元组（tuple）

元组也是任意对象的集合，元组不能修改，使用小括号表示

1）索引

与字符串索引类似

2）切片

与字符串切片类似

3）元组的删除

del tuple：删除整个元组

4）元组的内置函数

# 返回元素数量：num=len（tuple_1）
# 元组中元素的最大值：max(tuple_1)
# 元组中元素的最小值：min（tuple_1）
tump = (1, 2, 3, 4, 0)
print(max(tump))  # 4
print(min(tump))  # 0
print(len(tump))  # 5

5）字符串、列表、元组之间相互转换

# 要转换成列表：list()
# 要转换成元组：tuple()
# 要转换成字符串：””.join()(注意：如果列表或者元组中有数字的时候，在转换为字符串的时候会报错)
list = ['a', 'b', 'c']
print('-'.join(list))  # a-b-c
tmp = tuple(list)
print(tmp)  # ('a', 'b', 'c')

12、字典（dict）

当数据量特别大的时候，适合使用字典，字典属于映射类型，没有索引，只有键值对

字典是另一种可变容器模型，且可存储任意类型对象。

字典的格式：

dict_1={“name”:”一”，”sex”：”男”，”ID”:”454647658658”}

其中：name是键（key），一是值（value）。需要注意：键是唯一的，值可以不唯一。

既然字典可以通过键快速的定位元素的位置

1）访问字典

dic = {'name':'aaa', 'age':18}
print(dic['name'])  # aaa，如果存在键，则返回值
print(dic['aaa'])  # KeyError: 'aaa'，如果不存在键，则报错

2）修改/添加字典元素

dic = {'name':'aaa', 'age':18}
dic['name'] = 'bbb'
print(dic)   # {'name': 'bbb', 'age': 18}，存在该键值对，则修改值
dic['aaa'] = 'test'
print(dic)   # {'name': 'bbb', 'age': 18, 'aaa': 'test'}，不存在该键值对，则添加

3）删除字典元素

dic = {'name': 'bbb', 'age': 18, 'aaa': 'test'}
del dic['aaa']  # {'name': 'bbb', 'age': 18}，删除key值为aaa的元素
print(dic)
a = dic.pop('age')  # 18，删除key值为age的元素，并赋值给变量a
print(dic, a)  # dic = {'name': 'bbb'}
dic.clear()  # {}，清空字典元素
print(dic)

4）字典遍历

# 字典包含四种遍历方法
dic = {'name': 'bbb', 'age': 18, 'aaa': 'test'}
# 1、遍历字典的键
for i in dic:
    print(i)  # name,age,aaa
for i in dic.keys():
    print(i)  # name,age,aaa
# 2、遍历字典的值
for i in dic.values():
    print(i)  # bbb,18,test
# 3、遍历字典的元素
for i in dic.items():
    print(i)  # ('name', 'bbb'),('age', 18),('aaa', 'test')

13、集合（set）

集合可以表示任意元素的集合，无序的并且是唯一的。因此集合可以做为字典的键

创建一个空集合，必须使用set()，而不是{}，因为{}是用来创建空字典的

同数学中的集合基本一样，也可以进行 子，并，交，差运算

1）声明和访问集合

set1 = set()
print(type(set1))  # <class 'set'>
# 可以利用集合无序的并且是唯一的特性，对集合快速去重
list1 = [1, 2, 3, 4, 1, 2, 3]
print(list(set(list1)))  # [1, 2, 3, 4]

2）增加元素

set1 = set()
set1.add('abc')
print(set1)  # {'abc'}

3）删除元素

set1 = set('ababcd')  # 可以利用集合无序的并且唯一的特性，对字符串去重
print(set1)  # {'b', 'c', 'a', 'd'}
set1.pop()  # 删除随机的一个元素
print(set1)  # {'c', 'a', 'd'}
set1.remove('a')  # 删除集合中指定的元素
print(set1)  # {'c', 'd'}
set1.clear()  # 清空集合
print(set1)  # set()
del set1  # 删除集合
print(set1)  # NameError: name 'set1' is not defined

4）集合的运算

set_1=set("abcde")
set_2=set("bcdf")
x=set_2<set_1  # 子集
print(x)  # False
x=set_1.union(set_2)  # 并集
print(x)  # {'f', 'b', 'a', 'd', 'c', 'e'}
x=set_1.intersection(set_2)  # 交集
print(x)  # {'b', 'd', 'c'}
x=set_1.difference(set_2)  # 差集
y=set_2.difference(set_1)
print(x)  # {'a', 'e'}
print(y)  # {'f'}

14、条件控制

1）if单分支

# if 条件语句：
# 语句块
a = 10
if a % 2 == 0:
    print(f'{a}是偶数！')  # 10是偶数！

2）if……else双分支

#  if  条件语句：
#      语句1  # 条件满足执行此行
#  else：
#      语句2  # 条件不满足执行此行
a = 10
if a % 2 == 0:
    print(f'{a}是偶数！')
else:
    print(f'{a}是奇数！')

3）if嵌套

a = 10
if a % 2 == 0:
    print(f'{a}是偶数！')  # if条件满足执行此句
    if a <= 10:  # 上一层if条件满足判断执行此句
        print(f'{a}是小于10的偶数！')  

4）if……elif多分支

a = int(input('请输入年龄：'))
if a <= 18:
    print(f'{a}岁属于少年')
elif a > 18 and a <= 60:
    print(f'{a}岁属于壮年')
else:
    print(f'{a}岁属于老年')

15、循环语句

1）while循环

# while 条件：
#      满足时执行的语句
n = 100
sum = 0
counter = 1
while counter <= n:
    sum = sum + counter
    counter += 1
print("1 到 %d 之和为: %d" % (n,sum))

# while嵌套：
#   while 条件1：
#      满足时执行的语句
#      while 条件2：
#         满足时执行的语句


# break和continue
# break用于退出循环，continue用于跳过本次循环
count = 0
while count < 5:
   print (count, " 小于 5")
   count = count + 1
   if count == 4:
       break  # 当count值为4，则退出循环

# while和else配合使用
count = 0
while count < 5:
   print (count, " 小于 5")
   count = count + 1
else:
   print (count, " 大于或等于 5")

2）for循环

# 1）for循环语句
# for 变量 in 序列或迭代对象：
#    语句
list = ['red', 'blue', 'green']
for i in list:
    print(i)

# 2）range（），是python内置函数，可以生成一个数字序列
# range（start，end，step）
# range函数前闭后开
for i in range(1,5):
    print(i)

# 3）for循环嵌套
for i in range(1, 10):
    for j in range(i, 10):
        print(f'{i}*{j}={i*j}', end='\t')
    print()