Let's start learning python

Posted on | In

Python是一种易于学习，功能强大的编程语言。它具有高效的高级数据结构和面向对象编程的简单而有效的方法。Python优雅的语法和动态类型及其解释特性使其成为大多数平台上许多领域的脚本编写和快速应用程序开发的理想语言。

一、环境搭建

各种平台下的安装
1.unix & linux下安装
1
2
3
4
5
6
# 这里安装3.x.x版本的Python
$ wget https://www.python.org/ftp/python/3.7.2/Python-3.7.2.tgz
$ tar -zxvf Python-3.7.2.tgz
$ cd Python-3.7.2
$ ./configure
$ make && make install
2.MAC安装Python

MAC系统都自带有Python2.7环境，这里还是安装python3.x的版本，可以前往官网下载对应的pkg包进行安装，也可以下载源码包进行安装。

3.Windows安装Python

前往官网找到对应的安装包，一般就下载 executable installer，x86 表示是 32 位机子的，x86-64 表示 64 位机子的。

环境变量设置
1.unix/Linux
1
$ export PATH="$PATH:/usr/local/bin/python"
2.windows
1
2
# C:\Python 是Python的安装目录
path=%path%;C:\Python
测试python是否可用
1
2
3
4
5
$ python3
Python 3.7.0 (v3.7.0:1bf9cc5093, Jun 26 2018, 20:42:06)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>

二、基础语法

标识符

Python标识符是用于标识变量，函数，类，模块或其他对象的名称。 标识符以字母A到Z或a到z或下划线_开头，后跟零个或多个字母，下划线和数字（0到9）。
以下是Python标识符的约定

  • 类名以大写字母开头。所有其他标识符以小写字母开头。
  • 用单个前导下划线启动标识符表示标识符是私有的，如_foo
  • 启动带有两个前导下划线的标识符表示强私有标识符。如__foo
  • 如果标识符也以两个尾部下划线结尾，则标识符是语言定义的特殊名称。如__foo__
保留字

保留字即关键字，我们不能把它们用作任何标识符名称。Python 的标准库提供了一个 keyword 模块，可以输出当前版本的所有关键字。

1
2
import keyword
keyword.kwlist

行与缩进

Python没有提供大括号{}来指示类和函数定义或流控制的代码块。代码块由行缩进表示，这是严格执行的。 缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。如：

1
2
3
4
if True:
    print("True")
if False:    
    print("False")

注释

Python中单行注释以#开头，如：

1
2
# 这是一个单行注释
print("Python") #注释

Python中多行注释可以用多个#号，或者使用三个单引号'''，或者三个双引号"""进行块注释，如下：

1
2
3
4
5
6
7
8
9
'''
先用单引号
进行多行注释
'''
"""
再用双引号
进行多行注释
"""
print('Hello World!')

语句

Python语句可以以;作为结束符也可以省略，当在单行使用多个语句时可以用;进行分割。如：

1
numVal = 10;listVal = [1, 2, 3, 4];

Python中的语句通常以新行结束，也允许使用行反斜杠\来表示该行应该继续。如：

1
2
3
4
total = 1 + \
	    2 + \
	    3
print(total)

其中语句中包含[]，{}或()时不需要反斜杠\进行连接。如：

1
2
3
4
total = [1,
	     2,
	     3,
	     4]

三、数据类型

1.数字类型

数字类型包括 int(整型)、float(浮点型)、bool(布尔型)、complex(复数)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 1. 整型
foo = 10
print(foo, type(foo))
# 2.浮点型
foo = 10.10
print(foo, type(foo))
# 3. 复数
foo = 2 + 1j
print(foo, type(foo))
print('复数的实部:'+str(foo.real),'复数的虚部:'+str(foo.imag))
print('复数的实部:%s 复数的虚部:%s' %(foo.real, foo.imag))
# 使用多个变量赋值
a, b, c = 10, 10.10, 2 + 1j
print(type(a), type(b), type(c))

2.字符串类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
'''
注意：
	1. 反斜杠可以用来转义，字符串前加r可以让反斜杠不发生转义。
	2. 字符串可以用+连接，用*重复
	3. 字符串索引从左往右从0开始，从右往左从-1开始
'''
# 声明空字符串
foo = ''
foo1 = str();
print(foo, type(foo), foo1, type(foo1))
# 声明一个字符串
foo = 'Hello Python3'
print(foo, type(foo))
# 字符串下标取从左到右是0开始，从右到左是-1开始
print(foo[0], foo[3])
# 字符串下标从哪到哪以:分割
print(foo[0:1], foo[1:3], foo[2:-1])
# 字符串从下标至结束
print(foo[0:], foo[2:])
# 输出字符串两次
print(foo * 2)
# 使用\转义
print('Hello \n Python3') # \n会换行
print('Hello \\n Python3') # 使用\转义 让\n原样输出
print(r'Hello \n Python3') # 字符串前加r，使其原样输出
# 使用+进行拼接
foo = 'Hello'
print(foo + ' Python3')
3.布尔类型
1
2
3
4
trueFoo = True
falseFoo = False
print(trueFoo, type(trueFoo))
print(falseFoo, type(falseFoo))
4.列表
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
'''
注意：
	1. list可以被索引和切片
	2. list可以使用+进行拼接
	3. list中的元素是可变的
'''
# 声明空列表
foo = []
foo1 = list()
print(foo, type(foo), foo1, type(foo1))
# 声明一个列表
foo = [1, 2, 3, 4, 5, 6]
print(foo, type(foo))
# 下标索引从左到右从0开始，从右到左则-1开始
print(foo[1], foo[3], foo[-1], foo[0:2], foo[2:])
# 列表截取支持可以接收三个参数，第三个参数代表截取的步长
print(foo[0:5:2])
# 列表是可变的
foo[0] = 99
foo[1:3] = [22, 33] 
print(foo)
# 输出两次列表
print(foo * 2)
# 连接列表
foo1 = [7, 8, 9, 10]
print(foo + foo1)
5.元组
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
'''
注意：
	1. 元组也可以被索引和切片
	2. 元组也可以使用+进行拼接
	3. 元组中的元素是不可修改的
	4. 注意构造包含 0 或 1 个元素的元组的特殊语法规则
'''
foo = (1, 2, 3, 4, 5, 6)
print(foo, type(foo))
# 下标索引从左到右从0开始，从右到左则-1开始
print(foo[1], foo[3], foo[-1], foo[0:2], foo[2:])
# 元组元素是不可变的，如果元素是列表可变
foo = (1, 2, [3, 4], 5, 6)
# foo[0] = 10 这里会报错
foo[2][1] = 20
print(foo)
# 构造一个空元组
foo = ()
foo1 = tuple()
print(foo, type(foo), foo1, type(foo1))
# 构造一个元素的元组
foo = (1) # 这种方法构造出来的类型不是元组,需使用以下方法：
foo1 = (1,)
foo2 = 1,
print(foo, type(foo), foo1, type(foo1), foo2, type(foo2))
6.集合
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
'''
注意：
	1.可以使用{}或者set()函数创建集合，但是创建空集合必须用set()，因为{}是用来创建一个空字典的
	2.集合是无序、不可修改的
	3.集合会自动去重
	4.set()至多只能传一个参数
'''
# 声明空集合
foo = set()
print(foo, type(foo))
# 声明一个集合
foo = set('123hello')
foo1 = {1, 2, 4, 8, 4, 3, 5}
print(foo, type(foo), foo1, type(foo1))
# 测试元素是否在集合中
print('o' in foo, 10 in foo1)
# 声明两个集合
foo = {1, 3, 4, 6, 5, 8, 20, 53}
foo1 = {2, 4, 7, 22, 20, 5}
# 计算差集
diff = foo - foo1
diff2 = foo1 - foo
print(diff, type(diff), diff2, type(diff2))
# 计算并集
diff = foo | foo1
print(diff, type(diff))
# 计算交集
diff = foo & foo1
print(diff, type(diff))
# 对称差集  两个集合不同时存在的元素
diff = foo ^ foo1
print(diff, type(diff))
7.字典
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
'''
注意：
	1.可以使用{}或者dict()创建字典
	2.字典是一种映射类型，它的元素是键值对
'''
# 声明空字典
foo = {}
print(foo, type(foo))
# 声明一个字典
foo = {'name':'jacky','age':'18','sex':'man'}
print(foo,type(foo))
foo = dict([('name','jacky'),('age',20),('sex','man')])
print(foo, type(foo))
foo = dict(name='jacky',age=30,sex='man')
print(foo, type(foo))
foo = {x : x ** 2 for x in(2, 4, 6, 8)}
print(foo, type(foo))
# 获取字典的值
foo = {'name':'jacky','age':'18','sex':'man'}
print(foo['name'], foo['age'], foo['sex'])
# 获取字典所有的键
fooKey = foo.keys()
print(fooKey, type(fooKey))
#获取字典所有的值
fooVal = foo.values()
print(fooVal, type(fooVal))
# 清空字典
print(foo.clear(), foo, type(foo))

参考