Python基础

内容一：python概述

Python是一门跨平台、开源、免费的解释型高级动态编程语言。

• 两种使用方式

交互式：命令式编程/函数式编程
代码文件方式：代码缩进、适当的空行、适当的注释

• **版本：**Python目前存在2.x和3.x两个系列的版本，互相之间不兼容

• python编程规范

1.缩进：
-类定义、函数定义、选择结构、循环结构、with块，行尾的冒号表示缩进的开始。
-python程序是依靠代码块的缩进来体现代码之间的逻辑关系的，缩进结束就表示一个代码块结束了。
-同一级别的代码块的缩进量必须相同。
2.每个import语句只导入一个模块，最好按标准库、扩展库、自定义库的顺序依次导入。
3.注释
单行注释：# 
多行注释："""..."""  '''...'''

• pip对拓展库的安装

pip install libname（库名）
#安装包一般以whl为后缀名，表示python扩展包的windows环境下的二进制文件

• 标准库与扩展库对象的导入与使用

1.import moduleName1[, moduleName2[…]]

这种方法一次可以导入多个模块。但在使用模块中的类、方法、函数、常数等内容时，需要在它们前面加上模块名。

import math
x=math.sin(math.radians(30))
Print(x)

2.from moduleName import *

这种方法一次导入一个模块中的所有内容。使用时不需要添加模块名为前缀，但程序的可读性较差。

from math import *
x=sin(radians(30))
print (x)

3.from moduleName import object1[, object2[…]]

这种方法一次导入一个模块中指定的内容，如某个函数。调用时不需要添加模块名为前缀。

from math import sin,radians
x=sin(radians(30))
Print(x)

• 入门案例中的__name__属性

模块是一种程序（代码）的组织形式。它将彼此具有特定关系的一组Python可执行代码、函数或类组织到一个独立文件中，可以供其它程序使用。在Python中，一个.py文件就称之为一个模块（Module）

# 按间距中的绿色按钮以运行脚本。
if __name__ == '__main__':
    print_hi('PyCharm')

通过Python程序的__name__属性可以识别程序的使用方式：

• 如果作为模块被导入，则其__name__属性的值被自动设置为模块名；
• 如果作为程序直接运行，则其__name__属性值被自动设置为字符串__main__。

内容二：内置对象，运算符，表达式，关键字

2.1 内置对象

• python中一切都是对象，函数和类也是对象

• python中的对象有内置对象，标准库对象和扩展库对象，其中内置对象可以直接使用

• python内置对象

2.1.1 常量与变量

• 常量是指不能改变的字面值：一个数字，一个字符串，一个元组均为常量

• 变量是指值可以变化的量，且变量的类型也可以随意（在python中，无需声明变量，可以通过赋值来创建变量）

x = 5
x, y = 1, "hello"
#变量的赋值虽然无需声明，但python解析器会根据等号右侧的表达式推断出变量的类型
# 判断变量的类型
type(x)
isinstance(x, int)

• python的赋值语句：

1.首先会把等号右侧的表达式值计算出来
2.然后在内存中找一个位置把值存储进去
3.最后创建变量引用这个内存地址
#Python一个变量如果未赋值，则称该变量是“未定义的”。在程序中使用未定义的变量会导致错误。
#在Python中，可以把任意数据类型赋值给变量，同一个变量可以反复赋值，而且可以是不同类型的变量

2.1.2 整数，实数，复数

• 整数的进制

二进制，以0b开头。
八进制，以0o开头。
十六进制，以0x开头。

• 数的大小

Python支持任意大的数字，具体可以大到什么程度仅受内存大小的限制。

• 实数的精度

由于精度的问题，对于实数运算可能会有一定的误差，应尽量避免在实数之间直接进行相等性测试，而是应该以二者之差的绝对值是否足够小作为两个实数是否相等的依据。
>>> 0.4 - 0.1             #实数相减，结果稍微有点偏差
0.30000000000000004
>>> 0.4 - 0.1 == 0.3      #应尽量避免直接比较两个实数是否相等
False
>>> abs(0.4-0.1 - 0.3) < 1e-6    #这里1e-6表示10的-6次方
True

• 数的运算隐式转换规则

在数字的算术运算表达式求值时会进行隐式的类型转换，如果存在复数则都变成复数，如果没有复数但是有实数就都变成实数，如果都是整数则不进行类型转换。

• 复数的表示与运算

x = 3 + 4j
y = 5 + 6j
print(x + y)     # 8+10j
print(x * y)     #-9+38j
abs(x)          # 5.0   
print(x.imag)   # 实部3.0
print(x.real)   # 虚部4.0

2.1.3 字符串（简述）

在Python中，没有字符常量和变量的概念，只有字符串类型的常量和变量，单个字符也是字符串。使用单引号、双引号、三单引号、三双引号作为定界符来表示字符串，并且不同的定界符之间可以互相嵌套。

>>> x = 'Hello world.'                 #使用单引号作为定界符
>>> x = "Python is a great language."  #使用双引号作为定界符
>>> x = '''Tom said, "Let's go."'''    #不同定界符之间可以互相嵌套

>>> x = 'good ' + 'morning'            #连接字符串
>>> x
'good morning'

>>> x = 'good ''morning'               #连接字符串，仅适用于字符串常量
>>> x
'good morning'
>>> x = 'good '
>>> x = x'morning'                     #不适用于字符串变量
SyntaxError: invalid syntax

>>> x = x + 'morning'                  #字符串变量之间的连接可以使用加号
>>> x
'good morning'

x = 'good ''morning'				   #字符串重复
print(x * 3)

2.1.4 列表，元组，字典，集合（简述）

>>> x_list = [1, 2, 3]                 #创建列表对象
>>> x_tuple = (1, 2, 3)                #创建元组对象
>>> x_dict = {'a':97, 'b':98, 'c':99}  #创建字典对象
>>> x_set = {1, 2, 3}                  #创建集合对象
>>> print(x_list[1])            #使用下标访问指定位置的元素
2
>>> print(x_tuple[1])           #元组也支持使用序号作为下标
2
>>> print(x_dict['a'])          #字典对象的下标是“键”
97
>>> 3 in x_set                  #成员测试
True

2.2 python运算符与表达式

• 表达式

在Python中，单个常量或变量可以看作最简单的表达式，使用除赋值运算符之外的其他任意运算符和函数调用连接的式子也属于表达式。

• 运算符规则

运算符优先级遵循的规则为：算术运算符优先级最高，其次是位运算符、关系运算符、成员测试运算符、逻辑运算符等，算术运算符遵循“先乘除，后加减”的基本运算原则。

• 运算符用法

2.2.1 算数运算符

# 加法运算（当连接的不是同一个类型的元素时会报错：适用于列表，元组，字符串）
x = [1, 2, 3] + [4]
y = (1, 2, 3) + (4,)
z = "aaa" + "bbb"

# 乘法运算（序列重复：适用于列表，元组，字符串）
x = [1, 2, 3]
print(x * 3)

# 除法运算
print(3 / 2)        #数学传统意义上的除法
print(15 // 4)       #如果两个操作数都是整数，结果为整数
print(15.0 // 4)      #如果操作数中有实数，结果为实数形式的整数值
print(-15//4)     #向下取整

# 取余运算
print('%c, %f' %(65, 65))#将65格式化为字符和整数

# 幂运算（从右向左运算）
print(9 ** 0.5)#平方根
print(9 ** 2)#平方

2.2.2 关系运算符

python关系运算符可以连用，要求操作数之间必须可比大小。

print(1 < 3 > 5) #等价于1 < 3 and 3 > 5 结果为False
print("hello" > "Hello") #字符串会逐个比较大小
print([1, 2, 3] > [1, 1]) #列表会逐个比较大小
#集合中的关系运算符
print({1, 2, 3} > {1, 2}) #用于判断前者是不是后者的超集
print({1, 2, 3} == {3, 2, 1}) #判断前后两个集合是否相等（所以元素相同）

2.2.3 成员测试运算符

成员测试运算符in用于成员测试，即测试一个对象是否包含另一个对象

print(3 in [1, 2, 3])
print(3 in range(1, 10, 1))
print('abc' in 'abcd') #子字符串测试

用于循环

for i in (3, 4, 5):
    print(i, end='\t')

2.2.4 集合运算符

x = {1, 2, 3}
y = {3, 4, 5}
print(x | y) #并集运算
print(x & y) #交集运算
print(x ^ y) #对称差集运算
print(x - y) #差集运算

2.2.5 逻辑运算符

• 逻辑运算符and、or、not常用来连接条件表达式构成更加复杂的条件表达式，并且and和or具有惰性求值或逻辑短路的特点，当连接多个表达式时只计算必须要计算的值。
• 另外要注意的是，运算符and和or并不一定会返回True或False，而是得到最后一个被计算的表达式的值，但是运算符not一定会返回True或False

>>> 3>5 and a>3              #注意，此时并没有定义变量a
False
>>> 3>5 or a>3               #3>5的值为False，所以需要计算后面表达式
NameError: name 'a' is not defined
>>> 3<5 or a>3               #3<5的值为True，不需要计算后面表达式
True
>>> 3 and 5                  #最后一个计算的表达式的值作为整个表达式的值
5
>>> 3 and 5>2
True
>>> 3 not in [1, 2, 3]       
False
>>> 3 is not 5
True

2.2.6 其他运算符

#python中不支持 i++ 和 i--的表示
#下标运算符'[]', 属性访问运算符'.'

2.3 python常用的内置函数

内置函数是Python内置对象类型之一，不需要额外导入任何模块即可直接使用。

2.3.1 类型转换与判断

1.进制转换（参数均是整数）
print(bin(0xf))#二进制
print(oct(15))#八进制
print(hex(15))#十六进制

2.强制类型转换
2.1 float()#将整数或字符串转换为小数形式
print(float(3))
print(float('3.5'))
print('inf')
2.2 complex(real，imag)#转化为复数
2.3 int()#转换为整数
print(int(3.5))
print(int('1111', 2))#将二进制转十进制
print(int('17', 8))#将八进制转十进制
print(int('0xf', 16))#将十六进制转十进制
print(int('   15'))#去除空白转为整数
2.4 编码转换
ord() #返回Unicode码 即Ascii码
chr() #返回Unicode对于的字
2.5 str() #强转为字符串
2.6 序列结构强制类型转换
把参数指定的可迭代对象转换成列表，元组，字典，集合或者不带参数时创建空的序列结构
print(list(range(5)))
print(list("1234"))//如果里面是字符串会将他们一一转换存储在列表
print(tuple(range(5)))
print(dict(zip("1234", "abcd")))
print(set("11225544"))
2.7 字符串值的计算【eval(字符串)】
1.如果里面是字符串，可以求出字符串的值(可以求出表达式的值)
print(eval('3 + 4'))
2.也可以在特定情况下，去除字符串的双引号，恢复到原来状态
print(eval(str([1,2,3,4])))
2.8 类型判断函数    
type()和isinstance(变量，变量的类型)//可以检查转换类型
type的值为<class 'int'> = int

2.3.2 最值与求和

max()、min()、sum()这三个内置函数分别用于计算列表、元组或其他包含有限个元素的可迭代对象中所有元素最大值、最小值以及所有元素之和。

len()返回迭代对象的长度：只适合于列表，元组，集合，字典，字符串，以及range()对象，不适合map，zip，生成器对象

from random import choices
a = choices(range(1, 101), k=10)
print(max(a), min(a), sum(a), sum(a)/len(a))

#max和min指定大小规则：key=函数/lambda表达式
print(max(['2', '111']))
print(max(['2', '111'], key=len))

2.3.3 输入与输出

//输入：输出来的值都是字符串，必要的时候可以使用内置函数int()、float()或eval()对用户输入的内容进行类型转换
x = input("提示语")

//输出：
print(v1,v2...,sep=' ',end='\n')
sep:指定数据之间的分隔符，默认为空格
end:表示结束符，默认为换行
//格式化输出
#方法一：
print("我是%s,我今年%d" % (name,age))
%s:表示在字符串中占位字符串
%d:表示在字符串中占位整数
%f:表示在字符串中占位小数
#方法二：f-string
print(f"我是{name},我今年{age}")

//举例
a = [1,2,3,4]
print("列表为：{}".format(a))#{}为占位符，当有多个占位符要添加索引
print("列表为：%s" %a)
print("{0}{1}".format("列表为：",a))
print(f"列表为：{a}")

2.3.4 排序与逆序

sorted()对列表、元组、字典、集合或其他可迭代对象进行排序并返回新列表。

b = list(range(11))
from random import shuffle
shuffle(b)
print("原序列为：", b)
print("排序后序列为：" ,sorted(b))
print("按字符串的长度排序", sorted(b, key=lambda i : len(str(i)), reverse=True))

reversed()对可迭代对象进行翻转（首尾交换）并返回可迭代的reversed对象。

r = reversed(b)
for i in r:
    print(i, end=" ")

2.3.5 枚举与迭代

enumerate()函数用来枚举可迭代对象中的元素，返回可迭代的enumerate对象，其中每个元素都是包含索引和值的元组

//返回enumerate可迭代对象，将每一个元素转换成索引和值的元组(key,value)
l1 = list(enumerate(list(range(3))))
l2 = list(enumerate("abc"))
print(l1)
print(l2)

2.3.6 map函数

内置函数map()把一个函数func依次映射到序列或迭代器对象的每个元素上，并返回一个可迭代的map对象作为结果，map对象中每个元素是原序列中元素经过函数func处理后的结果，不对原对象做处理。

map:表示一种映射关系
1.map(函数对象，函数的形参)
def add5(v):                    #单参数函数
    return v+5
list(map(add5, range(10)))      #把单参数函数映射到一个序列的所有元素

def add(x, y):                  #可以接收2个参数的函数
    return x+y
list(map(add, range(5), range(5,10)))   #把双参数函数映射到两个序列上

2.map(数据关系，所转换的对象)
list(map(str, range(5)))        #把列表中元素转换为字符串

2.3.7 reduce函数

函数reduce()可以将一个接收2个参数的函数以迭代累积的方式从左到右依次作用到一个序列或迭代器对象的所有元素上，并且允许指定一个初始值。

>>> from functools import reduce
>>> seq = list(range(1, 10))
>>> reduce(lambda x, y: x+y, seq)
45

2.3.8 filter函数

#将一个单参数函数作用到一个可迭代对象上，返回其中使该函数返回true的值组成的filter对象
filter对象可以通过强制转换打印出相应的值
filter(函数名，可迭代对象)
如果没有指定函数的值，即None则返回迭代对象中为True的值，对原迭代对象不做任何修改
>>> seq = ['foo', 'x41', '?!', '***']
>>> def func(x):
    return x.isalnum()                  #测试是否为字母或数字

>>> filter(func, seq)                   #返回filter对象
<filter object at 0x000000000305D898>
>>> list(filter(func, seq))             #把filter对象转换为列表
['foo', 'x41']

2.3.9 range()函数

range()是Python开发中非常常用的一个内置函数，语法格式为range([start,] end [, step] )，有range(stop)、range(start, stop)和range(start, stop, step)三种用法。该函数返回range对象，其中包含左闭右开区间[start,end)内以step为步长的整数。参数start默认为0，step默认为1。

range([start],stop,[step]):start默认为0，step默认为1均可省略，只有stop不可以省掉

print(list(range(1, 10, 2)))
print(list(range(9, 0, -2)))
#随机数的生成
a = choices(range(1,101),k = 10)//产生1-100的10个随机数
#打乱随机生成的数
random.shuffle(list(range(11)))

2.3.10 zip函数

#zip() 用来把多个可迭代对象中的元素压缩到一起，返回一个可迭代的zip对象，其中每个元素都是包含原来的多个可迭代对象对应位置上元素的元组
zip(可迭代对象1，可迭代对象2....)
list(zip('abcd', [1, 2, 3]))             #压缩字符串和列表
[('a', 1), ('b', 2), ('c', 3)]

注意：
1.zip，enumerate，filter，map只能访问一次，访问过的元素将不存在
2.zip对象中元素的个数取决于最短的那个序列对象中的元素个数

2.4.编码

1.ascil : 8bit,主要存放英文，数字，特殊符号

2.gbk：16bit，主要存放中文和亚洲字符，兼容ascil

3.unicode:16bit和32bit两个版本，全世界所有国家的文字和信息

4.utf-8：可变长度的unicode，英文8bit，欧洲文字16bit，中文24bit，一般数据传输和存储的时候使用

#编码：s.decode(“编码类型”)：根据不同的编码类型，将所写的数据转换成不同的编码形式
#解码：s.decode("对应的解码类型")：根据所要的解码类型，将所写数据进行解码