Python3 基础

环境：ubuntu16.04 Python 3.5.2
参考：http://www.runoob.com/python3/python3-tutorial.html

1.基础语法

1）注释
单选注释#
多选注释”“”
多行注释用三个单引号 ”’ 或者三个双引号 “”” 将注释括起来

#!/usr/bin/python3
if True:
    print("Hello,Python")
else:
    print("False")

#print("test---1")  被注释掉
"""
print("test---2")
print("test---3")
"""
print("end")

# ./hello.py 
Hello,Python
end

2）缩进
用缩进来表示代码块，不需要使用大括号 {}
缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数

#!/usr/bin/python3
if True:
    print("True")
else:
print("False")

# ./hello.py 
  File "./hello.py", line 5
    print("False")
        ^
IndentationError: expected an indented block
Python严格地要求代码缩进，缩进的代码块相对于上一级是从属关系

3）空行
函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
4）等待用户输入

#!/usr/bin/python3
input("\n\n please press enter then exit")

# ./hello.py 


 please press enter then exit 
一旦用户按下 enter 键时，程序将退出

5）输出
print()
默认输出是换行的
6）模块导入import
将整个模块(somemodule)导入，格式为： import somemodule

#!/usr/bin/python3
import sys
print("\n python's path:",sys.path)

# ./test.py 

 python's path: ['/home/xxx/python3_Runoob', '/usr/lib/python35.zip', '/usr/lib/python3.5', '/usr/lib/python3.5/plat-x86_64-linux-gnu', '/usr/lib/python3.5/lib-dynload', '/usr/local/lib/python3.5/dist-packages', '/usr/lib/python3/dist-packages']
打印python的路径

2.基本数据类型

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建

#!/usr/bin/python3
count = 100
moneny = 10.5
name = "Tom"

print(count)
print(moneny)
print(name)
# ./test.py 
100
10.5
Tom

Python3 有六个标准数据类型：
不可变数据（四个）：Number（数字）、String（字符串）、Tuple（元组）、Sets（集合）
可变数据（两个）：List（列表）、Dictionary（字典）
1）Number数字
Python3 支持 int、float、bool、complex（复数）

#!/usr/bin/python3
count = 100
moneny = 10.5
china = True
print(type(count))  #内置的 type() 函数可以用来查询变量所指的对象类型。
print(type(moneny))
print(type(china))

# ./test.py 
<class 'int'>
<class 'float'>
<class 'bool'>

2）String 字符串
Python中的字符串用单引号(‘)或双引号(“)括起来，同时使用反斜杠()转义特殊字符。

字符串的截取的语法格式如下：

变量[头下标:尾下标]
索引值以 0 为开始值，-1 为从末尾的开始位置。
加号 (+) 是字符串的连接符， 星号 (*) 表示复制当前字符串，紧跟的数字为复制的次数

#!/usr/bin/python3

str = 'Runoob'

print (str)          # 输出字符串
print (str[0:-1])    # 输出第一个到倒数第二个的所有字符
print (str[0])       # 输出字符串第一个字符
print (str[2:5])     # 输出从第三个开始到第五个的字符
print (str[2:])      # 输出从第三个开始的后的所有字符
print (str * 2)      # 输出字符串两次
print (str + "TEST") # 连接字符串
# ./test.py 
Runoob
Runoo
R
noo
noob
RunoobRunoob
RunoobTEST

与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如word[0] = ‘m’会导致错误。
3）List 列表
List（列表） 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
列表是写在方括号([])之间、用逗号分隔开的元素列表。
和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式如下：
变量[头下标:尾下标]
索引值以 0 为开始值，-1 为从末尾的开始位置。
加号（+）是列表连接运算符，星号（*）是重复操作

#!/usr/bin/python3
list = ["abcd",123,2.2,"baby",50]
print(list)
print(list[0])
print(list[1:2])
print(list[3:])
# ./test.py 
['abcd', 123, 2.2, 'baby', 50]
abcd
[123]
['baby', 50]
注意：

1、List写在方括号之间，元素用逗号隔开。
2、和字符串一样，list可以被索引和切片。
3、List可以使用+操作符进行拼接。
4、List中的元素是可以改变的。

4）Tuple（元组）
元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。
元组中的元素类型也可以不相同

#!/usr/bin/python3
list = ("abcd",123,2.2,"baby",50)
print(list)
print(list[0])
print(list[1:2])
print(list[3:])
# ./test.py 
('abcd', 123, 2.2, 'baby', 50)
abcd
(123,)
('baby', 50)
注意：

1、与字符串一样，元组的元素不能修改。
2、元组也可以被索引和切片，方法一样。
3、注意构造包含0或1个元素的元组的特殊语法规则。
4、元组也可以使用+操作符进行拼接。

5）Set（集合）
集合（set）是一个无序不重复元素的序列。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
创建格式：
parame = {value01,value02,…}
或者
set(value)

#!/usr/bin/python3
student = {"Tom","Jim","Mary","Tom","Jak"}
print(student)
# ./test.py 
{'Jak', 'Mary', 'Jim', 'Tom'}  # 输出集合，重复的元素被自动去掉

6）Dictionary（字典）
字典（dictionary）是Python中另一个非常有用的内置数据类型。
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用”{ }”标识，它是一个无序的键(key) : 值(value)对集合。
键(key)必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的。

#!/usr/bin/python3
tinydict = {"name":"bshui","age":20,"number":12345}
print(tinydict)  # 输出完整的字典
print(tinydict.keys()) # 输出所有键
print(tinydict.values())  # 输出所有值

# ./test.py 
{'number': 12345, 'age': 20, 'name': 'bshui'} 
dict_keys(['number', 'age', 'name'])
dict_values([12345, 20, 'bshui'])
注意：

1、字典是一种映射类型，它的元素是键值对。
2、字典的关键字必须为不可变类型，且不能重复。
3、创建空字典使用 { }。

3.Python算术运行符

以下假设变量a为10，变量b为21：

4.条件控制if语句

if 条件1:

elif 条件2:

else:

#!/usr/bin/python3
score = int(input("please input your score:"))
level =int( score/10)
if level<6:
    print("your leve is ..very bad")
elif level==6:
    print("level=6 just so so")
elif level==7:
    print("level=7 come on")
elif level>=8:
    print("good level is ",level)

root@bshui-virtual-machine:/home/bshui/python3_Runoob# ./test.py 
please input your score:50
your leve is ..very bad
root@bshui-virtual-machine:/home/bshui/python3_Runoob# ./test.py 
please input your score:75
level=7 come on
root@bshui-virtual-machine:/home/bshui/python3_Runoob# ./test.py 
please input your score:90
good level is  9

5.循环语句

1）While循环
while 判断条件：
语句

#!/usr/bin/python3
n = 100
sum = 0
i = 1

while i <= n :
    sum += i
    i+=1

# ./test.py 
teh sum is: 5050

2）For语句
Python for循环可以遍历任何序列的项目，如一个列表或者一个字符串
for 变量 in 语句:
语句

#!/usr/bin/python3
languages = ["C","C++","Java","Python","QT"]

for x in languages:
    print(x)
# ./test.py 
C
C++
Java
Python
QT

break 语句可以跳出 for 和 while 的循环体

6.迭代器

迭代器是Python最强大的功能之一，是访问集合元素的一种方式。
迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器有两个基本的方法：iter() 和 next()。
字符串，列表或元组对象都可用于创建迭代器：

#!/usr/bin/python3
list = [1,2,3,4]
it = iter(list)
for x in it:  迭代器对象可以使用常规for语句进行遍历
    print(x)
# ./test.py 
1
2
3
4

#!/usr/bin/python3
import sys
list = [1,2,3,4]
it = iter(list)

while True:
    try:
        print(next(it)) # 输出迭代器的下一个元素
    except StopIteration:
        sys.exit()
# ./test.py 
1
2
3
4

7.生成器

在 Python 中，使用了 yield 的函数被称为生成器（generator）。
跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。
调用一个生成器函数，返回的是一个迭代器对象

#!/usr/bin/python3
import sys

def fibonacci(n):
    a,b,counter = 0,1,0
    while True:
        if(counter > n):
            return
        yield a  #每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值
        a,b = b, a+b
        counter += 1

f = fibonacci(10)

while True:
    try:
        print(next(f),end=" ")
    except StopIteration:
        print()
        sys.exit()
# ./test.py 
0 1 1 2 3 5 8 13 21 34 55 

8.函数

函数能提高应用的模块性，和代码的重复利用率
简单的规则：
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None
def 函数名（参数列表）:
函数体

#!/usr/bin/python3

def area(width,height):
    return width*height

w=4
h=5
# ./test.py 
width= 4  height= 5  area= 20

变量作用域
Python 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4种，分别是：
L （Local） 局部作用域
E （Enclosing） 闭包函数外的函数中
G （Global） 全局作用域
B （Built-in） 内建作用域

9.数据结构

列表可以修改，而字符串和元组不能

#!/usr/bin/python3
a = [66.25,333,111,111,333,1,123]
print(a.count(333),a.count(111),a.count('x'))
a.insert(2,-1)
a.append(333)
print(a.count(333),a.count(111),a.count('x'))
print(a)
a.sort()
print(a)
# ./test.py 
2 2 0
3 2 0
[66.25, 333, -1, 111, 111, 333, 1, 123, 333]
[-1, 1, 66.25, 111, 111, 123, 333, 333, 333]

10.模块

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数等功能

#!/usr/bin/python3
import sys  #引入 python 标准库中的 sys.py 模块；这是引入某一模块的方法

for i in sys.argv:
    print(i)
# ./test.py a b c 1
./test.py
a
b
c
1

搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块 support，需要把命令放在脚本的顶端

# cat support.py 
#!/usr/bin/python3

def print_func(par):
    print(par)
    return
# cat test.py 
#!/usr/bin/python3
import support  # 导入自定义的模块，support.py放在和test.py同一目录下
support.print_func("Hello support model") #用模块里包含的函数了
# ./test.py 
Hello support model

from…import 语句
Python的from语句让你从模块中导入一个指定的部分到当前命名空间中
每个模块有各自独立的符号表，在模块内部为所有的函数当作全局符号表来使用
包：包是一种管理 Python 模块命名空间的形式，采用”点模块名称”。
比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B

11.输入和输出

Python两种输出值的方式: 表达式语句和 print() 函数。
第三种方式是使用文件对象的 write() 方法，标准输出文件可以用 sys.stdout 引用。
如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。
如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。

str()： 函数返回一个用户易读的表达形式。
repr()： 产生一个解释器易读的表达形式
格式化输出str.format()
括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换

#!/usr/bin/python3
print("{}address: {}!".format("net","www.baidu.com"))
# ./test.py 
netaddress: www.baidu.com!

读取键盘输入
Python提供了 input() 内置函数从标准输入读入一行文本，默认的标准输入是键盘。
input 可以接收一个Python表达式作为输入，并将运算结果返回。

#!/usr/bin/python3
str = input("please input:")
print("your input context is:", str)
# ./test.py 
please input:hello i love python
your input context is: hello i love python

读和写文件
open() 将会返回一个 file 对象，基本语法格式如下:open(filename, mode)
filename：filename 变量是一个包含了你要访问的文件名称的字符串值。
mode：mode决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默认文件访问模式为只读(r)。

#!/usr/bin/python3
f = open("./foo.txt","w") # 打开一个文件
f.write("Python is a good language very good\n")
f.close # 关闭打开的文件
# cat foo.txt 
Python is a good language very good

#!/usr/bin/python3
f = open("./foo.txt","w")
f.write("Python is a good language very good\n")
f.close
f = open("./foo.txt","r")
str = f.read()
print(str)
f.close
# ./test.py 
Python is a good language very good

f.readline() 会从文件中读取单独的一行。换行符为 ‘\n’。f.readline() 如果返回一个空字符串, 说明已经已经读取到最后一行
f.readlines() 将返回该文件中包含的所有行

#!/usr/bin/python3
f = open("./support.py","r")
str = f.readlines()
print(str)
f.close
# ./test.py 
['#!/bin/usr/python3\n', 'def print_func(name)\n', '\tprint(name)\n']

另一种方式是迭代一个文件对象然后读取每行

#!/usr/bin/python3
f = open("./support.py","r")

for line in f:
    print(line, end="")
# ./test.py 
#!/bin/usr/python3
def print_func(name)
    print(name)

f.write()
f.write(string) 将 string 写入到文件中, 然后返回写入的字符数
如果要写入一些不是字符串的东西, 那么将需要先进行转换

#!/usr/bin/python3
f = open("./foo.txt","w")

value = ("www.baidu.com", 18)

s = str(value)
f.write(s)
f.close
# cat foo.txt 
('www.baidu.com', 18)

12.File文件方法

13.错误及异常

语法分析器会指出出错的一行，并且在最先找到的错误的位置标记一个小小的箭头
异常：即便Python程序的语法是正确的，在运行它的时候，也有可能发生错误。运行期检测到的错误被称为异常。
大多数的异常都不会被程序处理，都以错误信息的形式展现在这里:
异常处理：try语句按照如下方式工作；
首先，执行try子句（在关键字try和关键字except之间的语句）
如果没有异常发生，忽略except子句，try子句执行后结束。
如果在执行try子句的过程中发生了异常，那么try子句余下的部分将被忽略。如果异常的类型和 except 之后的名称相符，那么对应的except子句将被执行。最后执行 try 语句之后的代码。
如果一个异常没有与任何的except匹配，那么这个异常将会传递给上层的try中。

#!/usr/bin/python3
while True:
    try:
        x = int(input("Please enter a number:"))
        break
    except ValueError:
        print("Oops! That was not valid number.Try again ")
# ./test.py 
Please enter a number:2.0
Oops! That was not valid number.Try again 
Please enter a number:1

抛出异常：Python 使用 raise 语句抛出一个指定的异常

14 .面向对象

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
实例变量：定义在方法中的变量，只作用于当前实例的类。
继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟”是一个（is-a）”关系（例图，Dog是一个Animal）。
实例化：创建一个类的实例，类的具体对象。
方法：类中定义的函数。
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法
类定义：
class ClassName:
xxxxx

#!/usr/bin/python3
class MyClass:
    i = 12345
    def f(self):
        return "hello python"

x = MyClass() # 实例化类
print(x.i)    # 访问类的属性和方法
print(x.f())
# ./test.py 
12345
hello python

在类地内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。