Python学习初阶：Python基本介绍及常用数据类型

*************************************************************************************************************

本部分内容是以《Python程序设计：任务式驱动教程》@作者：郑凯梅 这本书为基础对Python相关知识进行介绍，结合网上资料以及相关例程对Python相关知识进行解读和总结，帮助Python学习者快速进阶

*************************************************************************************************************

#1前言

1.1Python的特色

（1）简单

（2）易学

（3）免费、开源

（4）可移植性

（5）解释性：Python语言写的程序不需要编译成二进制代码。Python的解释器把源代码转换为字节码的中间代码形式，然后翻译成计算机使用的机器语言并运行。

（6）面向对象：及支持面向过程也支持面向对象。面向过程的编程中，Python程序由模块或者函数构建；在面向对象的编程中，Python程序通过数据和功能组成的类来构建。

（7）可扩展性

（8）库丰富

1.2Python的开发工具

IDLE、Emacs、Vim、Eclipse

1.3Python的文件类型

Python文件通过Python解释器解释运行。在Windows中必须要有python.exe与pythonw.exe,只要设置正确的环境变量，即可运行Python程序

（1）源代码

扩展名是.py，pym文件是Windows下开发图形用户接口（GUI）

（2）字节代码

Python源文件经过编译后生成以.pyc为为扩展名的文件。PYC文件是字节码文件，不能使用文本编辑工具打开或修改。PYC文件与平台无关，可运行在Windows、Unixs、Linux等操作系统中。PY文件直接运行后，即可得到PYC文件，或通过脚本生成该类型的文件。例如：

import py_compile

py_compile.compile('hello.py')

（3）优化代码

扩展名为.pyo的文件是经过优化的源文件

1.4Python的编码规范

（1）缩进

默认值，4个空格表示一个缩进层次

（2）行的最大长度

可使用\，即反斜杠符号对行进行延续

（3）导入

import通常放在文件的顶部

（4）运算符

最好在二元运算符的两侧各放置一个空格，赋值 = 、比较 == > < in 、not in 、is、is not 及布尔运算（and，or not）

（5）注释

#+空格+内容+空格+#

（6）命名约定

单词首字母大写；模块名应该是不含下划线的、简短的、小写的名字——模块名被映射到文件名，有些文件系统大小写不敏感；

双下划线"__"作为前导为类的私有属性；全局变量使用一个前缀下滑线"_"防止其被导出

#2Python基本语法

2.1基本数据类型

Python中的基本数据类型主要分为两种，即数值数据类型和字符串数据类型。Python使用对象模型来存储数据，每一个数据都有相对应的内置类。新建一个数据，实际就是初始化并生成一个对象，即所有数据都是对象。
Python中的对象有下述三个特性。

（1）标识：对象的内存地址，可以使用函数id()来获得

（2）类型：决定了该对象可以保存什么值，可执行何种操作，需要遵守什么规则，可以使用函数type()来获得

（3）值：内存空间保存的真实数值

2.1.1数值

Python3支持int、float、bool、complex（复数）等几种数值数据类型

（1）整型（int）

正整数或者负整数，无小数点。无大小限制，可以作为long使用

整型的四种表现形式如下：

《1》二进制：0b开头

《2》八进制：0o开头

《3》十进制：正常表示

《4》十六进制：0x开头

这四种进制数据的转换，通过Python的内置函数bin()、oct()、int()、hex()来实现

（2）浮点型（float）

也可以用科学计数法来表示2.5e3

（3）布尔型（bool）

布尔型数据的运算结果是常亮True或False。这两个常量的值是1和0

（4）复数（complex）

complex（a,b）------->复数的实部a和虚部b都是浮点型数据

2.1.2字符串

Python中字符串是用单引号（'）、双引号（''）、三引号（'''）括起来，同时使用反斜杠（\）转义特殊字符的一段文字，常用转义字符可以自行百度，其中，print(r'content')-----开头的r可以使得转义字符不进行转义，字符串的前面加上字母r就表示raw string，也叫原始字符串。

2.1.3变量

Python是一种动态类型的语言，在赋值过程中可以绑定不同类型的值。Python中的变量不需要声明，但是每个变量在使用前必须赋值。只有变量赋值后，才会创建该变量并分配内存空间

注意：

《1》变量命名规则：（下划线或字母）+（任意数目的字母、数字、下划线）

《2》（_X_）前后都有下划线的变量名是系统定义的变量名，对解释器有特殊意义

《3》变量赋值方式：

普通赋值：y =1

链式赋值：x = y = a = 1

多元赋值：x，y = 1,2

增量赋值：x += 1      (理解同C，变量左侧，常量右侧)

2.1.4正则表达式

正则表达式RE（Regular Expression）是定义模式的字符串，其本质是字符串，主要是用来匹配目标字符串 ，并对其进行处理，如替换、分隔等。

本章暂不进行深究，后续在涉及爬虫相关的知识到会进行补充

2.2运算符与表达式

Python运算符包括赋值运算符、算术运算符、关系运算符、逻辑运算符、位运算符、成员运算符。表达式是将不同类型的数据（常量、变量、函数）用运算符按照一定的规则连接起来的式子。

2.2.1运算符

/：除法，5/2=2.5

**：幂指数，5**2=25

//：整除，5//2=2

 2.2.2关系运算符

2.2.3赋值运算符

2.2.4位运算符

把数字转换为二进制进行位运算，运算结果再转换为原来的进制

2.2.5成员运算符

2.3Python的输入

变量名= input("输入提示信息字符")

注意：

(1)通过int()、float()、eval()函数与input()函数的组合，可以输入整数或者小数。

（2）多输入时可以使用eval()函数，例如：x,y,z=eval(input())

2.4Python输出

print()的语法如下：

print(*object, sep=' ', end= '\n', file=sys.stout, flush = False)

值得注意的是：format()函数是Python2.6之后的版本新增的格式化输出函数，功能十分强大。其特点是用{}代替%进行格式控制，且不限制参数个数，位置不必按照顺序书写；一个参数可以多次使用，也可以不使用

例:

a,b =eval(input("please input the number\n"))
print('{1:.3f},{0:.4f}' .format(a,b))

输入为1.7,2.3

输出结果为2.300,1.7000

2.5Python数学运算

Python除支持基本的数学运算外、还提供其他语言不常见的数学特性，如分数运算和复数运算。Python的math模块包含高级运算中常见的三角函数、统计函数、对数函数等

2.5.1分数

Python的模块fractions中定义了一个特殊的对象，叫做Fraction。该对象的属性包括分子和分母。一旦定义了分数对象，就可以进行各种各样的算术运算了。在使用分数对象之前，需要引入fractions模块，语法如下：

from fraction import Fractions

Fraction对象有3种实例化方式：

(1)t = Fraction(1, 3)

(2)t = Fraction(3.5)

(3)t = Fraction('3/5')

2.5.2复数

complex(real,imag)

#3Python流程控制

主要分为三种：顺序结构、选择结构和循环结构

3.1顺序结构

3.2选择结构

3.2.1if-else条件语句

if 条件：
    条件为真时要执行的语句
else：
    条件为假时要执行的语句

3.2.2if-elif-else判断语句

if-elif-else语法格式如下：

if 条件1：
    条件1为真时执行的语句块1
elif 条件2：
    条件2为真时执行的语句块2
.
.
.
elif 条件n：
    条件n为真时执行的语句块n
else：
    上述条件均不满足时执行的语句块n+1
    

3.2.3if语句的嵌套

if 条件1：
    if 条件2：
        条件1为真且条件2为真时执行的语句块1
    else：
        条件1为真且条件2为假时执行的语句块2
else：
    条件1为假时执行的语句块3

例程如下：判断三角形的类型:是直角还是钝角还是锐角

a,b,c = eval(input('please input the a,b,c\n'))
if(a > b):
    (a, b)= (b, a)   #这点很有意思，在C中需要一个额外的容器来存放交换的中间值
if(a > c):
    (a, c)= (c, a)
if(b > c):
    (b,c) = (c, b)
#print(a,b,c)
if(a+b>c):
    if(a**2 +b**2 == c**2):
        print('This a zhijiao\n')
    elif(a**2 +b**2 > c**2):
        print('This is dunjiao\n')
    elif(a**2 +b**2 < c**2):
        print('This is ruijiao\n')
else:
    print('This is not a triangle!')

3.3循环结构

3.3.1while循环

while循环语法格式如下：

[初始化语句]
while(循环条件)：
    语句块
    [迭代语句]

流程如下：

执行到while循环的时候，先判断“循环条件”，若结果为“True”，则执行下面缩进的循环体；执行完毕，再次判断“循环条件”，同上，为“True”则继续执行循环体，为“False”则不再执行循环体，循环结束。循环结束后，继续执行循环结构之后的语句。

注意：

（1）初始化语句：循环控制变量赋初值，或其他循环中用到的变量的初始化。

（2）循环条件：循环结构继续执行的条件，是一个结果为True或False的表达式。

（3）迭代语句：通常是循环控制变量的改变，且朝着循环结束条件的方向变化，使得循环可以正常结束。

例程如下：

根据公式求解pi的大小，要求最后的相邻两个数值之差小于1e-10

import fractions
n = 1
sum = 1.0
s1 = fractions.Fraction(2,3)
temp = 0.0
results = 0.0

while(abs(s1-temp) >= 1e-20):
    sum =sum * s1
    temp = s1
    n = n+1
    s1 = (2*n)**2/((2*n-1)*(2*n+1))
results = sum*4
print('the final resaults is {}' .format(results))

3.3.2for 循环语句

在为一个集合（序列和其他可迭代对象）的每个元素都执行一个相同的代码块，使用for语句更有效。

for语句的基本形式如下：

for <变量> in <序列>：
    循环体语句块

其中，序列可以是等差数列、字符串、列表、元组或者是一个文件对象。在执行过程中，变量依次被赋值为序列中的每一个值，然后执行缩进语句块。序列中的所有元素被扫描完毕，循环结束。

注意：

（1）缩进问题

（2）序列可以是后面要讲得数据结构的对象，也可以是通过range来产生的一个连续的数字列表。range不是一个真正的函数，它是一种数据类型，代表不可操作的连续数字。

（3）range用法如下：

@1   range（stop）
产生0~x-1的整数序列

例：range（6）产生0、1、2、3、4、5

@2    range（start，stop）
产生start、start+1、....、stop-1这系列的整数。
要求start和stop是整数且start<stop

例：range（0,5）产生0、1、2、3、4

@3    range（start，stop，step）

例：range（3,10,2）产生3、5、7、9的整数序列

for循环语句使用例程1——计算n的阶乘

#calculate n!= 1*2*3*4*....*n
number = int(input('Please enter an integer\n'))
results = 1
for i in range(1,number+1):
    results = results*i
print(results)

3.3.3break和continue

@1 break

功能：从循环体当前位置退出。当循环体执行到这个语句时，循环马上退出并终止。

@2 continue

功能：结束当前循环，开始新一轮循环。即当前循环中的剩余语句不再执行，程序跳转到循环体的头部重新开始下一轮

例程，判断一个输入是否是素数：

import os

if os.name == 'nt':
    import msvcrt
    def getch():
        return msvcrt.getch().decode()
else:
    import sys, tty, termios
    fd = sys.stdin.fileno()
    old_settings = termios.tcgetattr(fd)
    def getch():
        try:
            tty.setraw(sys.stdin.fileno())
            ch = sys.stdin.read(1)
        finally:
            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
        return ch
while(1):
    a = input('Please enter an integer\n')
    if(getch()== 0x1b):
        break
    elif(a > 0):
        flag = 0
        for i in range(2,a):
            if(a%i == 0):
                flag = 1
        if(flag == 1):
            print('{} is not sushuo' .format(a))
        else:
            print('{} is sushuo'.format(a))

在这里，值得注意的是以下这段函数，因为在linux中并没有getch()，所以def定义一个getch函数，并且由于termios的使用，下面这段程序在Linux中只能通过terminal进行使用

import os

if os.name == 'nt':
    import msvcrt
    def getch():
        return msvcrt.getch().decode()
else:
    import sys, tty, termios
    fd = sys.stdin.fileno()
    old_settings = termios.tcgetattr(fd)
    def getch():
        try:
            tty.setraw(sys.stdin.fileno())
            ch = sys.stdin.read(1)
        finally:
            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
        return ch

3.3.4循环中的else语句

（1）else在while循环语法中的使用

[初始化语法块]
while(循环条件)：
    语句块
    [迭代语句]
else：
    语句块

注意：循环条件为False时跳入else中

（2）else在for循环中的使用

for <变量> in <序列>：
    循环体语句块
else：
    语句块

注意：else部分只在for循环正常终止时执行（而不是遇到break语句）

3.3.5嵌套循环 

例程输出素数，输出100-200之间的素数：

#output the sushuo from 100 to 200
flag = 0

for i in range(100,200):
    for j in range(2,i):
        if(i%j == 0):
            break
        if(j == i-1):
            print('{}' .format(i))

3.3.6字符串的遍历

（1）字符串列表

for <变量> in ['string1','string2',....'stringn']
    循环体语句块
else：
    语句块

（2）单个字符串

for <变量> in 字符串：
    循环体语句块
else：
    语句块

3.3.7pass语句

循环结构中，for或者while语句中至少包含一条语句的缩进语句块，若需要一个没有循环体语句块的循环结构，此时至少可以使用pass语句，pass是什么也不做的一个占位符 

#4列表与元组

4.1列表

列表是Python中最基本的数据结构，也是最常用的Python数据类型。列表的数据相不需要具有相同的类型。列表中为每一个元素分配一个数字，表示它的位置与索引。第一个索引是0，第二个索引是1，以此类推。

列表的特点是通过一个变量存储多个数据值，且数据类型可以不同。另外，列表可以修改、如添加或者删除列表中的元素。

Python中内置了很多函数或方法来操作列表，主要包括索引、分片、列表操作符加或乘，以及其他一些函数和方法，如计算列表长度、最大值、最小值等函数以及添加、修改或者列表元素的方法

4.1.1列表的创建以及使用

@1列表的创建

列表的创建是用方括号括起来所有元素，并且元素之间用逗号分隔。

例：对于mylist = ['100', 'apple',4.5,'山东'，'2019-6-11',100]

（1）in操作符遍历

for item in mylist:
    print(item, end = ' ')

（2）借由range()函数来遍历

for i in range(len(mylist)):
    print('{}'.format(mylist[i]), end = ' ')

（3）借由iter()函数（这部分仍然存在疑惑？？？）

for item in iter(mylist):
    print('{}'.format(item))

（4）借由enumerate可生成索引及数值

for list_id,list_value in enumerate(mylist):
    print('{} {}\n'.format(list_id, list_value))

@2列表元素的访问及列表的切片

切片语法格式：
a:b且a<b
如list[m:n]则表示得到一个索引从m到n-1的字列表

@3更新列表

a =[1,2,4,3,4,5]
a[3] =3  #把索引号3的位置的元素的数值修改为3
a.append(8)#尾部增加一个8

@4删除列表

list=[1,2,4,3,2,6,7,4]
del list[1]   #删除索引号为1的
del list[2:4]#删除2、3两个索引号的元素
del list#删除整个列表


list.pop(2)  #删除索引号为2的元素
list.pop() #m默认删除尾部的元素

@5列表操作符

list1 = [1,2,3,'',2019]
list2 =[4,5,6,'ee',2018]
Python语句                          结果
len(list1)                           5
list1 + list2        [1,2,3,'',2019,4,5,6,'ee',2018]
list1 * 2            [1,2,3,'',2019,1,2,3,'',2019]
[3] in list1                        True
[3] not in list1                    False
for x in list1:print(x)            1,2,3, ,2019

@6列表操作的函数及方法

函数操作中，列表对象作为函数的参数；而方法操作中，通过列表对象名.方法名（参数表）的形式调用方法。关于方法的定义和使用，见高级篇中面向对象的单元

列表中的常见函数：
例：
list1 = [1,2,'11','asda']
list2 = [1,2,2,5,6]
函数名            实例                结果                 描述
len(list1)    print(len(list1))        4                  长度
max(list2)    print(max(list2))        6           所针对列表的元素只能为数据类型(int float)
min(list2)    print(min(list2))        1                  同上
sum(list2)    print(sum(list2))        16                 同上
list(seq)     print(list('a','b'))   ['a','b']            将元组转换为列表

列表中的常见方法如下：此部分需要时自行百度即可
函数名            实例                结果                 描述
append(obj)    t=['a','b']
               t.append(1)         ['a','b',1]        增加一个元素，或者是嵌套一个列表

count(obj)
extend(obj)                                           合并列表
index(obj)
insert(obj)
pop(obj)
remove(obj)
reverse(obj)
sort(obj)

@7嵌套列表

Python支持嵌套列表，即列表中的元素也是列表，也称多维列表。最好不要超过三层

例程：
mylist[['1001','a',1,2222,4.5],
       ['10','1011',1,22,1.5],
       ['1','2019',1,21,0.5]]
for each in mylist:
    for item in each:
        print(item,end = ' ')

4.1.2 列表解析

Python的强大特性之一是对list的解析。通过对list中的每个元素应用一个函数进行计算，讲一个列表映射为另一个列表。

<表达式> for <变量> in <列表>
或
<表达式> for <变量> in <列表> if<条件>

1、简单的列表解析

t = [x for x in range(1,5)]
print(t)        #结果为[1,2,3,4]
t = [x**2 for x in range(1,5)]
print(t)        #结果为[1,4,9,16]

2、两次循环
t = [x for x in range(1,5)]
s = [y for y in range(5,8)]
print([x*y for x in t for y in s])

3、还有其他一些列表解析方法，如遍历对角线、乘法、等等，
这方面其实可以去使用一些Python的库，如numpy等等，这些库都对于解决矩阵问题是更好的选择

4.1.3列表实现堆栈

栈是一种特殊的线性表，它限定插入和删除数据元素的操作只能在线性表的一端进行。栈的这种特性是“后进先出”。在栈中，插入操作称为入栈，删除操作称为出栈。

1、使用insert()和pop()的方法模拟堆栈
s =[]
s.insert(0,'a')
s.insert(0,'b')
s.insert(0,'c')
print(s)
print(s.pop(0))        #删除列表第一个元素
print(s.pop(0))        #继续删除列表第一个元素

2、用append()和pop()方法模拟堆栈
s=[]
s.append('a')
s.append('b')
s.append('c')
print(s)
print(s.pop(), end = ' ')
print(s.pop(), end = ' ')

4.1.4列表实现队列

队列也是一种特殊的线性表，它限定插入和删除数据元素的操作分别在线性表的两端进行。其中，插入元素的一端称为队头，删除元素的一端称为队尾。队列的操作特性是先进先出，在队列中，插入操作称为入队，删除操作称为出队。

4.2元组

元组与列表类似，也是元素的有序序列，元组与列表的区别：元组存储的值不能被修改，即这些数据值是不可改变的。元组中没有append（）、extend()、insert()

4.2.1元组的创建和使用

@1元组的创建

元组的定义通常是由逗号分隔，或者由圆柱括号括住的一个序列。列表是用方括号括住

例如：
t1 = ('Months','Years',1997,2000) #圆括号包围多个用逗号分隔的元素
t2 = (1,2,3,4,5)

t3 = 'a','b','c'       #多个用逗号分隔的元素，输出时自动带上圆括号

注意：
（1）元组中数据类型可以不同
（2）t=()表示创建一个空元组，而不是表达式
（3）创建只有一个元素的元组时，语句的末尾要加逗号
（4）可以使用tuple()函数把一个列表转换为元组

@2元组的访问和切片

同列表，可以单个索引。得到索引位置的元素，但是只能只读不可修改

@3元组操作符

+、-、in、 not in等等

@4删除整个元组

元素不可修改，但可以del删除整个元组

@5元组的函数与方法

4.2.2不可变和可变对象（本部分讲述了数值、字符串、元组都是对象，并不是原地修改，暂且pass）

对象是一个可以存储数据并且具有数据操作方法的实体

4.3字典

Python中的字典是另一种可变容器，且可存储任意类型的对象，如字符串、数字、元组等其他对象。字典是Python最强大的数据类型结构之一。

字典中的每个数据称为相，由两个部分构成：一部分称作值，存储有效数据；另一部分称作键，可以对数据进行索引，并且仅能被关联到一个特定的值，因此字典也被称为健/值对。

字典是Python语言中唯一的映射类型。映射关系中，哈希值（键，key）和指向的对象（值，value）是一对一的关系

4.3.1创建和使用字典

@1创建字典

字典名={健1：值1，健2：值2，...,健n:值n}
字典是用大括号括住的键值对的集合。字典的数据类型为dict
键与值均可为任意类型数据类型
注意：
（1）键与值之间用冒号隔开，项与项之间用逗号隔开
（2）键必须唯一，值可以不唯一
（3）键必须是一个不可变对象，即键可以是字符串、数值、元组，但不能是列表
（4）如果字典中的值为数字，最好使用字符串数字形式，例如，使用'no':'0040'而不是'no'：0040

例：
d1 = {1:'Monday',2:'tuesday',3：'wednesday',4:'Thursday',5:'Friday',6:'Saturday',7:'Sunday'}

@2字典的访问

<格式1>字典对象名[键]
注意：
（1）用一个不存的键进行索引，会产生KeyError异常
（2）注意大小写
（3）只能通过键来访问字典，不能通过数字索引，因为字典中的存储是无序的

例：
d1 = {'Name'：'John', 'Age':17, 'Class':'A01'}
print('d1[\'Name\'] :{}'.format(d1['Name']))

<格式2>为避免出现因键不存在而产生的异常，使用get()方法来访问
语法如下:
字典对象名.get(键，[键不存在时的提示信息])
d1 = {'Name':'John','Age':17,'Class':'A01'}
print(d1.get('Age'))
print(d1.get('Idno'))        #输出结果为：None

@3添加字典元素

通过赋值语句添加一个新的键值对

语法格式为：
字典对象名[新键] = 新值
例：
d1 = {'Name'：'John', 'Age':17, 'Class':'A01'}
d1['School'] = 'First Middle School'
print(d1)

@4修改字典元素

通过赋值语句修改已有的键值对

例如：
d1 = {'Name'：'John', 'Age':17, 'Class':'A01'}
d1['Age'] = 18
print(d1)        #输出结果中年龄变为18

@5删除字典元素或字典

使用del语句来删除字典中的一个元素或者整个字典

语法格式1：
del 字典对象名[键]        #键所在的项

语法格式2：
del 字典名                #删除整个字典

语法格式3：
字典对象名.clear()

@6检测字典中是否存在键

用 in 或者 not in 可以检测某个键中是否在字典中

语法格式1：
键 in 字典对象名        #输出结果是True或者False
语法格式2：
键 not in 字典对象名    #输出结果是True或者False
例：
d1 = {'Name'：'John', 'Age':17, 'Class':'A01'}
print('Name' in d1)
print('Name' not in d1)

4.4集合

集合是Python的一种数据类型。集合是一个无序不重复元素集，其基本功能包括关系测试和消除重复元素。集合对象还支持并、交、差、对称等操作。

4.4.1集合的创建和使用

@1创建集合 

由于集合没有自己的语法格式，只能通过集合的工厂方法set()和frozenset()创建。

（1）s1 = set('chocolate')
print(s1)            #结果是{'c', 't', 'h', 'l', 'e', 'a', 'o'}

（2）s1 = {'yohoo','hihi'}
print(s1)            #结果是{'yohoo','hihi'}
（3）用字典创建一个集合，集合的元素是字典的键
d1 = {'1':'one','2':'two','3':'three'}
print(set(d1))            #输出{'2','3','1'}，不过，其中键的顺序是随机的
（4）用列表创建一个集合，集合的元素是列表中不重复的元素
l1 = [1,3,4,2,4,2,1,,6,7]
print(set(l1))            #输出{1,2,3,4,6,7}  从小到大排序，且不重复

@2访问集合

@3集合中添加元素

（1）add()
集合对象名.add(元素)
（2）update()
集合对象名.update()

@4删除集合元素

（1）renmove()
集合对象名.remove([要删除的集合元素])
（2）discard()
集合对象名.discard([要删除的集合元素])
（3）pop()
集合对象名.pop()
随机删除一个元素，并返回该元素

4.4.2集合运算

例程如下：

s1 = set([1, 2, 3, 4, 5]) 
s2 = set([1,3])

                            Python的集合运算符
集合运算符            操作                 实例
-                    差                    s1-s2
&                    交                    s1&s2
|                    并                    s1|s2
!=
==
in
not in