Python的系统学习-1语法基础

1.1 Python语法基础

不能以软件开发的思想和思维方式，来学习面向数据科学的Python应用。
Python禅（The Zen of Python）：数据科学的思维，优雅的艺术，明确，简练。

# Python程序示例
# intx = int(input("请输入一个整数："))
intx = 21; x = 2044; z = 'asbd'

print("您输入的整数：", intx, x, z)
if intx % 2 == 0:
    print(intx)
    print("是偶数。")
else:
    print("是奇数")

1.1.1 标识符

所有语言，不仅仅指计算机语言，也包括人类语言等，都是由字符组成单词（标识符），单词构成（单）语句，然后是段落（复合语句、函数或方法），最后文章（应用程序）。

字母、数字和下划线’‘。Python 3 支持 UTF-8 字符集，也就是十六位编码，因此 Python 3 的标识符可以使用 UTF-8 所能表示的多种语言的字符，当然包含中文字符等。
以字母、下划线’'开头
区分大小写的
Python 关键字。Java中语法规则，自定义标识符不能和关键字同名，但Python可以和函数名/方法名等同名。如果标识符和关键字同名，则系统定义的关键字的功能失效。

# 应用模块 keyword 中的属性：kwlist，查看 Python 关键字
import keyword
keyword.kwlist

[‘False’,
‘None’,
‘True’,
‘peg_parser’,
‘and’,
‘as’,
‘assert’,
‘async’,
‘await’,
‘break’,
‘class’,
‘continue’,
‘def’,
‘del’,
‘elif’,
‘else’,
‘except’,
‘finally’,
‘for’,
‘from’,
‘global’,
‘if’,
‘import’,
‘in’,
‘is’,
‘lambda’,
‘nonlocal’,
‘not’,
‘or’,
‘pass’,
‘raise’,
‘return’,
‘try’,
‘while’,
‘with’,
‘yield’]

1.1.2 语句

1）简单语句
一行一句：Python 语言没有专门的语句结束符，如Java的’;‘。通常是一行一句，一行结束（回车Enter），程序语句自然结束。
一行多句：如果一行写多句代码，中间用’;‘分隔，注意行尾可以不写’;‘。
一句多行：如果一句分多行写，可以在逗号后面换行，或用续行符’'。（不建议。优雅的艺术：简单，直接……）

# 一行一句
x = 100
print(x)
# 一行多句
y = 200;print(y)
# 一句多行
z\
=\
300
print(z)

2）复合语句
Python 用’:'和代码缩进格式，表示复合语句块，注意，同一复合语句块的缩进必须对齐。

# 复合语句
if x < y:
    print(x)
    print('<')
    print(y)

3）空语句
因Python没有语句结束符，所以不能像Java一样写一个单独的’;'作为空语句。
Python定义了关键字 pass，表示空语句。

if x<y:
	pass

4）注释语句
以’# '开始的行，定义为单行注释语句。
单行注释语句快捷键：‘ctrl + /’。
Python多行文档注释语句（docString）：三引号括起来。

'单引号'
"双引号"
'''三引号'''
"""三双引号"""

1.1.3 数据类型基础

Python 3 定义了 6 种标准的数据类型：number（数字）、str（字符串）、list（列表）、tuple（元组）、set（集合）和 dict（字典）。
Python的数据类型，和我们之前学习的其他程序设计语言还是有较大区别的。比如，没有数组，但多了列表、元组、集合和字典等类似数组的类型。
另外，Python是面向对象语言，但和其他面向对象语言不同的是，比如Java语言，数据类型分为两大类：简单类型和引用（对象）类型，但Python语言的数据类型全部是引用类型，也就是说，Python语言的所有类型数据，不管是简单的整数，或复杂的数据字符串、字典等，全部以对象形式保存在内存，一切皆为对象。

number数字类型：
int，整数，长整型，没有大小限制。100,1234567890,……
float，小数，可以用科学记数法。12.2, 2.8e3,……
bool，True和False，分别对应1和0，并且可以和数字相加；
complex，复数，由实部和虚部两部分构成，a+bj 或 complex(a,b)，a和b都是浮点型。3.2+5j, complex(6,7.8)……

数据类型转换
Python属于强类型语言，不支持自动类型转换。（除 number 数字类型外。也就是说，整数、小数、复数和布尔类型可以自动转换，但其他类型不能自动转换，比如整数转换成字符串，Python不支持。）
强制类型转换，通过调用和数据类型同名的内置函数实现

序列sequence

不是独立的数据类型，而是泛指一类数据元素有先后顺序（序号，下标，索引）的容器类型。注意不是数据元素大小有序排列。

序列类型：字符串，列表，元组
序列操作：*索引访问，切片，重复，迭代，拆包式赋值
专用函数：求序列长度 len(); 排序 sorted(); 逆序 reversed(); 跟踪索引 enumerate(); 同步（并行）计算 zip()

1.1.4 变量和赋值

变量要先定义，后使用。
Python语言和我们学习过的其他大部分程序设计语言一样，变量必须先定义，后使用。但Python语言的变量定义非常简单，或者从某种角度讲，不能称之为变量定义。按照软件开发的语法，变量定义是指定数据类型，分配内存空间，但Python语言的变量定义，就是简单的起个名字，然后赋值，就完成了变量定义。所以，Python语言的变量，赋值即定义，没有定义变量的关键字，也不需要指定数据类型。这一点，有点像JavaScript。JavaScript定义变量，也不需要指定数据类型，变量的数据类型由赋值决定，但JavaScript有定义变量的关键字：var。Python更简单，关键字var也不用了。所以，我们可以换种更具体的表达：python的变量，是先赋值，后使用。

# Python中，通过直接赋值的方式声明变量，不需要定义数据类型。
# 变量的数据类型由赋值后内存中数据的类型决定。
# 定义变量 var1，赋值整数102，var1是整数类型。
var1 = 102
var1 = 1.23
var1 = True
var1 = 3.4 + 2.2j
# Python中，可以给同一个变量，依次赋值不同类型的数据，所以 Python 是动态类型语言。

python的变量是动态类型语言。
也就是Python变量的数据类型是可变的。其实，这一点也好理解。我们前面讲过，Python数据类型是引用类型，所有类型的数据都以对象形式保存在内存，变量指向存储数据的内存地址。所以不管是什么类型的数据，对于变量来讲，存储的都是内存地址。
赋值：拆包式赋值（可以同时给多个变量赋值，逗号,分隔）；链式赋值；

# 同时给多个变量赋值，变量名列表和值列表分别用逗号,分隔
# 拆包式赋值
var1, var2, var3 = "HHH", False, 108
var1, var2, var3
# 链式赋值，从右到左
var1 = var2 = var3 = 100
# 两个变量值调换
a = 100
b = 222
a,b = b,a

Python除了基本的赋值语句外，还支持两种特殊的赋值语法，一是拆包式赋值，可以同时给多个变量赋不同的值，赋值等号左边是用逗号隔开的多个变量名，右边是用逗号隔开的多个值，或者是容器类数据，比如列表、元组等；二，链式赋值，可以同时给多个变量赋同一个值。多个变量用赋值等号依次连接，赋值语句最后一个等号的右边是数据值。
最后，Python的内置函数dir()可以查看目前已经定义的所有变量；关键字del，可以删除已定义的变量。

• 查看已定义的所有变量：dir()
• 查看变量指向的内存地址：id(变量名)
• 查看变量指向的内存数据的类型：type(变量名)
• 删除已定义的变量：del 变量名

1.1.5 运算符和表达式

Python语言定义了算术运算符、关系运算符、逻辑运算符、位运算符、集合运算符，以及特殊运算符。
算术运算符:加、减、乘、除，还有整除、取余以及幂运算。
除法运算，包括除法，整除和取余。因为Python语言的整数、小数、复数，甚至布尔类型，都属于数字类型，所以Python的除法运算和其他语言的区别比较大。下面我们具体解释一下：
首先，除法，运算符是一个/斜杠，除法的运算规则比较简单，就是我们数学中的除法，不区分整数和小数，比如5/4，虽然5和4都是整数，但Python的除法运算的结果是1.25。
下面看整除，整除的运算符是//两个斜杠，运算规则是对除法的商下取整。比如5//4，商是1.25，整除的结果就是1；大于0的正数的整除比较简单。小于0的负数的整除，比如-5.6//4，除法的商是-1.4，所以整除的结果就是-1.4下取整，结果是-2；

5/4

5//4

关系运算符
关系运算符，包括等于，不等于，大于，大于等于，小于，小于等于。运算规则，就是大小比较.
唯一强调一点：Python语言中，布尔值可以参与关系比较运算。布尔值True参与运算时，自动转换为1；False转换为0。
逻辑运算符
逻辑运算符，包括逻辑与，逻辑或和逻辑非。
Python逻辑与的运算符是and关键字，或是or，非是not。
位运算符
位运算，转换为二进制位，进行运算，所有计算机语言都是相同的

# 内置函数 bin() 将十进制数据转换为二进制数据
bin(6)

特殊运算符
is / is not：判断是否指向同一个引用
in / not in：判断某个变量是否在给定容器（集合）中
math包：
最后，我们简单介绍Python语言中，和数学运算相关的包math。
首先，导入math包，import math
我们可以应用Jupyter Notebook代码提示功能，来查看math包中所有的属性和函数。
输入math.然后按Tab键，弹出列表中，就是math包中的属性和函数。

# 导入 math 包
import math
# 圆周率 pi
math.pi
# 三角函数
math.sin(1.2)
# 开方

1.1.6 字符串

字符串是单引号（‘单引号’）、双引号（“双引号”）或三引号（‘’‘三引号’‘’）配对括起来的零个、一个或多个字符组成的字符序列
序列类型，索引规则：从左到右，0开始，递增 1；从右到左，-1开始，递增 -1。
字符串访问：索引[index]访问一个字符，切片[start : stop : step]访问连续或不连续的多个字符。

# 字符串是单引号（'单引号'）、双引号（"双引号"）或三引号（'''三引号'''）配对括起来的零个、一个或多个字符组成的字符序列。
str1 = "可以应用'单引号'、\"双引号\"或'''三引号'''实现\"字符串嵌套\""
print(str1)

# 字符串运算
str1 = "asdawwada"
# 字符串是序列类型，支持索引和切片访问
# 字符串索引规则：从左到右，0开始，递增 1；从右到左，-1开始，递增 -1
# 访问：索引[index]或切片[start : end : step]

# 字符串索引
str1[0]
str1[-1]
# 切片 
str1[0:5:1]
str1[2:5]
str1[::]
str1[::3]
str1[-3:-8:-2]
str1[-6:-2]
str1[4:]

# 字符串连接 +
str2 = "abc" + "def"
# 字符串重复 *
str3 = "abdcde" * 3

# str.count(sub[,start[,end]])返回[start,end]内sub的非重叠出现次数，start和end可选
str1 = "aaabcbcabccbabc"
str1.count("abc")
str1.count("abc",5)
str1.count("abc",5,11)

# Python内置函数，读取序列长度（元素个数）
len(str1)

# str.endswith(sub[,start[,end]])字符串是否以指定子串sub结束
str1 = "adsadwadae"
str1.endswith("abc")

# str.startswith(sub[,start[,end]])字符串是否以指定子串sub开始
str1.startswith("Qing")

# str.find(sub[,start[,end]])返回字符串中首次出现子串sub的索引位置，start和end可选，未找到返回-1
str1.find("uni")

# str.split(sep==None)使用sep作为分隔符拆分字符串，返回字符串中单词的列表，默认为空格
str1.split()
str1.split("i")

# str.strip([chars])删除字符串首尾指定字符集chars，如果省略或 None，则删除空字符
str1 = " asdsada  "
str1.strip()
str1.strip("ads")

# str.upper()将字符串中所有字符转换为大写
str1.upper()

# str.lower()将字符串中所有字符转换为小写
str1.lower()

# 字符串 join()
'-'.join('abc')

# 字符的 Unicode 编码
# ord('解')
ord('a')
chr(97)

# Python正则表达式
import re
# 定义正则表达式
r1 = re.compile('[a-dA-D]')
# 匹配所有子字符串
r1.findall(str1)

1.1.7 列表

逗号,分隔，方括号[]括起来的有序集合对象类型

# 逗号,分隔，方括号[]括起来的有序集合对象类型，可变长度，异构，嵌套
# 是序列类型，支持索引和切片访问
# 索引规则：从左到右，0开始，递增 1；从右到左，-1开始，递增 -1
# 访问：索引[index]或切片[start : stop : step]
# 列表定义
list1 = [11,22,[1,2,3],"qingdao",True]
list2 = list("university")

# 索引和切片
list2[2]
list2[-3]
list2[2:8:2]
list2[::-1]

# 列表反向遍历，step步长为 -1
list2[::-1]
# 内置函数 reversed()，不改变列表本身，返回反向遍历的迭代器，可以用list()强制转换为列表
list(reversed(list2))
# 列表方法 reverse()，改变列表本身
list2.reverse()

# 列表长度，内置函数 len()
len(list1)

max()
min()
sum()

del list2
del list2[1]

# 列表元素值重复
list1 * 3

# 判断某一元素值是否在列表中
11 in list1

# 列表常用方法
# L.append(v)在列表L后面追加元素
list1 = [1,3,4,6,7]
list1.append(3)
list1

list2 = [3,5,8]
# 两个列表合并
list1 + list2
# 将参数列表合并到调用列表后面
list1.extend(list2)
list1
# 将参数以成员元素，追加到调用列表后面
list1.append(list2)
list1

# L.insert(index, value)在index位置插入元素value
list1 = [1,3,4,6,7]
list1.insert(1,8)
list1

# L.index(x[,start][,end])
list1 = [1,3,4,6,7]
list1.index(9)

# L.pop(index)删除索引index位置的元素
list1 = [1,3,4,6,7]
list1.pop(3)
list1
# del
del list1[1]

# L.remove(value)删除第一个值为value的元素
list1 = [1,3,4,6,7]
list1.remove(3)
list1

list1.clear()

# L.count(x)
list1 = [1,3,4,6,7,3]
list1.count(3)
# L.sort(key=None, reverse=False)对列表排序，修改本身的值
list1 = [1,8,3,4,6,5,7]
list1.sort()
list1
list1.sort?
# 内置函数排序 sorted(), 返回排序后的列表，不改变列表本身
sorted(list1)
# 拉链函数 zip(list1, list2)，两个列表并行迭代，返回迭代器
list1 = [1,3,5,7]
list2 = [2,4,6,8]
list(zip(list1, list2))
# 内置函数 enumerate()跟踪列表元素下标
list1 = [1,8,3,4,6,5,7]
list(enumerate(list1))

1.1.8 元组

逗号,分隔，圆括号( )括起来的固定长度，不可变的Python对象序列。

# 元组定义
t1 = (11,22,33,44,55)
t2 = 123,222,345
t3 = ((1,2,3),("a","b","c"),"qingdao")
t33 = (1,2,3),("a","b","c"),"qingdao"
t4 = tuple("Qingdao University")
t = (1)  #整数 1，不是元组
tt = (1,)

# 元组长度
len(t4)

max(t4)
min(t4)
sum()

# 访问：索引 & 切片
t4[5]
t4[-3]
t4[::]
t4[2:5:3]
t4[-1:-5:-1]

# 元组连接
t1+t3

# 重复
tt * 3

# 判断某一数据元素value是否在元组中
1 in tt

# 删除
del tt

# 元组拆包式赋值
a,b,c=t3
a,b,c

# count
t4.count("n")

1.1.9 集合

逗号,分隔，花括号{ }括起来的没有重复元素的无序集合体。

# 集合定义
set1 = {1,3,5,4,8}
# {}空花括号表示空字典，非空集合
set2 = {}
# set()函数创建空集合
set3 = set()
set4 = set([2,4,6,8])
# 添加新的元素
set1.add((111,222,333))

# 添加多个元素
set1.update((111,222,333))

# 删除元素
set1.remove(5)
# 集合运算函数
set1.issubset(set3)
set1.issuperset(set3)
set1.union(set4)
set1.intersection(set4)
set1.difference(set4)
# 用set()函数（强制类型转换）进行列表重复值过滤，即重复值只保留一个
list2 = [1,3,5,3,6,2,7,3,2,2,8]
list(set(list2))

# Python 中，集合分为 set 和 frozenset 两种。set 是可变对象，frozenset 是不可变对象。
s1 = {1,2,3,4}
s1.add(5)
s1.remove(2)

# 数据科学项目中，为保护数据，防止数据在分析过程中被修改，通常采用不可变对象技术。
fs1 = frozenset({1,2,3,4})
# fs1.add(5)

1.1.10 字典

字典，也称映射，由健/值对组成的无序可变集合。具体数据格式是，数据键和数据值之间用冒号分隔，多个键值对之间用逗号分隔，花括号括起来。类似json数据格式。dict = { key1:value1, key2:value2, … }
注意，字典中的健key必须是唯一的。
有关python的集合和字典，都是用花括号括起来，但数据元素的格式不同，同学们需要注意。另外，空花括号，表示空字典；如果要定义空集合，需要用数据类型内置函数set()。

# 字典定义
dict1 = {"id":"2020","name":"Tom","age":20}

# 空字典
dict2 = {}

# 访问：字典名[key]
dict1['name']

# 修改或添加新的value
dict1['age'] = 22
dict1['score'] = 99

# 删除
dict1.pop('age')

# 字典的常用方法
# dict.get(key, default=None)返回指定健key的值，若字典中没有指定的key则返回default
dict1.get("id")

# dict.items()以列表返回可遍历的（健，值）元组数组
dict1.items()

# dict.keys()以列表返回一个字典中所有的健
dict1.keys()

# dict.values()以列表返回字典中所有值
dict1.values()

# 遍历
for key in dict1:
    print(key, dict1[key])
    
for value in dict1.values():
    print(value)

for key,value in dict1.items():
    print(key,':',value)

1.1.11 迭代器与生成器

可迭代对象与迭代器* 迭代：遍历数据元素 * 可迭代对象（iterable）：可以通过循环遍历对象中的数据元素，一般用在for循环语句。比如Java语言中的迭代模式。 相对于序列，可迭代对象仅在迭代时产生数据，故可节省内存空间。 Python语言提供了若干内置可迭代对象：range、map、filter、enumerate、zip； 标准库itertools模块中包含各种迭代器。这些迭代器非常高效，且内存消耗小。 那么，什么样的数据对象，才是一个可迭代对象呢？ 所有的可迭代对象，都实现了__iter__()方法。Python中，除数字类型外，字符串、列表、元组、集合和字典，都是可迭代对象类型； * 迭代器（iterator）：是一种特殊的可迭代对象，不仅实现了__iter__()方法，同时实现了__next__()； 通过内置函数next()，调用迭代器的__next__()方法，可以依次遍历对象中的所有数据元素； * 迭代器对象必须实现两个方法：iter()和__next__()，二者合称为迭代器协议。 iter()用于返回对象本身，以方便for语句进行迭代，__next()__用于返回下一元素。 * 调用Python内置函数iter()可以获取可迭代对象的迭代器； * 判断是否为可迭代对象：collections.abc模块中定义了抽象基类Iterable，使用内置的isinstance，可判断一个对象是否为可迭代对象。 内置函数isinstance(对象名, Iterable)和collections模块。

list1 = [11,22,33,44,55]
# next(list1)
iter1 = iter(list1)
iter2 = list1.__iter__()
iter1.__next__()
iter2.__next__()
next(iter1)
next(iter2)
from collections.abc import Iterable
isinstance(list1, Iterable)
 
myList = [11,22,33,44,55]
# next(myList)
myIterator = iter(myList)
next(myIterator)

from collections.abc import Iterable
isinstance(myList, Iterable)

生成器与迭代器
生成器（generator）是指生产一个新的迭代器的函数。

返回值不用return语句，而用yield语句；
不是"立刻计算"，而是"惰性计算"（在调用生成器函数时，不会立刻执行它，而是推迟至需要调用其中的每个元素时才运行。）

def myFunc():
    for x in range(11):
        return x ** 2
myFunc()
def myGen():
    for x in range(11):
        yield x ** 2
myGen()
for x in myGen():
    print(x)

zip是可迭代对象，拼接多个可迭代对象iter1、iter2…的元素，返回新的可迭代对象，其元素为各系列iter1、iter2…对象元素组成的元组。如果各系列iter1、iter2…的长度不一致，则截断至最小系列长度。可以节省内存空间。

zip((1,2,3),'abc', range(3))
list(zip((1,2,3),'abc', range(3)))
list(zip('abc', range(10)))

多个可迭代对象的元素个数不一致时，如果需要取最大的长度，则需要使用itertools. zip_longest迭代器。

import itertools
list(itertools.zip_longest('ABCD', 'xy', fillvalue='-'))

enumerate是可迭代对象，用于枚举可迭代对象iterable中的元素，返回元素为元组（计数, 元素）的可迭代对象。

enumerate
list(enumerate('ABCD', start=10001))

itertools模块包含三个无穷系列的迭代器：

count(start=0, step=1) #从start开始，步长为step的无穷系列
cycle(iterable) #可迭代对象iterable元素的无限重复
repeat(object[, times]) #重复对象object无数次（若指定times，则重复times次）
from itertools import *
list(zip(count(3), 'abcde'))
list(zip(range(10), cycle('abc')))
list(repeat('God', 5))

itertools模块的accumulate迭代器用于返回累计和。

import itertools
list(accumulate((1,2,3,4,5)))
import operator
list(accumulate((1,2,3,4,5), operator.mul))

itertools模块的chain迭代器用于返回级联元素。

import itertools
list(itertools.chain((1,2,3),'abc',range(5)))
list(itertools.chain.from_iterable(['ABC', 'DEF']))

compress迭代器用于返回可迭代对象的部分元素。compress(data, selectors)
根据选择器selectors的元素（True/False），返回元素为True对应的data系列中的元素。当data系列或selectors终止时，停止判断。

import itertools
list(itertools.compress('ABCDEF', [1,0,1,0,1,1]))

截取迭代器itertools.dropwhile和takewhile，用于返回可迭代对象的部分元素。
dropwhile根据条件函数predicate处理可迭代对象的每个元素，丢弃iterable的元素，直至条件函数的结果为True；
takewhile则根据条件函数predicate处理可迭代对象的每个元素，返回iterable的元素，直至条件函数的结果为False。

import itertools
list(itertools.dropwhile(lambda x: x<5, [1,4,6,4,1]))
list(itertools.takewhile(lambda x: x<5, [1,4,6,4,1]))

切片迭代器itertools.islice
从索引位置start（第1个元素为0）开始，到stop（不包括）结束，步长为step（默认为1）。

import itertools
list(itertools.islice('ABCDEFG', 2))
list(itertools.islice('ABCDEFG', 2, 4))
list(itertools.islice('ABCDEFG', 2, None))
list(itertools.islice('ABCDEFG', 0, None, 2))

分组迭代器itertools.groupby
groupby返回的结果为迭代器，其元素为(key, group)，其中key是分组的键值，group为iterable中具有相同key值的元素的集合的子迭代器。

import itertools
data=[1,-2,0,0,-1,2,1,-1,2,0,0]; data1=sorted(data, key=abs)
for k, g in itertools.groupby(data1, key=abs):
    print(k, list(g))

返回多个迭代器itertools.tee
itertools模块的tee迭代器用于返回多个可迭代对象：tee(iterable, n=2) 返回可迭代对象iterable的n个（默认为2）迭代器。

import itertools
for i in itertools.tee(range(10), 3): 
	print(list(i))

组合迭代itertools.combinations和combinations_with_replacement
itertools模块的combinations（元素不重复）和combinations_with_replacement（元素可重复）迭代器用于系列的组合。

combinations(iterable, r)
combinations_with_replacement(iterable, r)
import itertools
list(itertools.combinations([1,2,3],2))
list(itertools.combinations([1,2,3,4],2))
list(itertools.combinations([1,2,3,4],3))
list(itertools.combinations_with_replacement([1,2,3],2))

排列迭代器itertools.permutations
itertools模块的permutations迭代器用于系列的排列：permutations(iterable, r=None) 返回可迭代对象iterable的元素的排列，组合长度为r（默认为系列长度）。

import itertools
list(itertools.permutations([1,2,3],2))
list(itertools.permutations([1,2,3]))

笛卡儿积迭代器itertools.product
itertools模块的product迭代器用于系列的笛卡儿积：product(*iterables, repeat=1) 返回可迭代对象iterables1、iterables2、…的元素的笛卡儿积，repeat为可迭代对象的重复次数（默认为1）。

import itertools
list(itertools.product([1,2],'abc'))
list(itertools.product([1,2],repeat=3))