python3练习

参考：http://www.runoob.com/python3/python3-tutorial.html

输入:

>>> a=input("input something:")
input something:hello world
>>> a
'hello world'

输出：加括号、不换行
>>> print("Hello, Python!")
Hello, Python!
>>> print "Hello, Python!"
  File "<stdin>", line 1
    print "Hello, Python!"
                         ^
SyntaxError: Missing parentheses in call to 'print'
>>> print("Hello, Python!", end="")
Hello, Python!>>>

指定解释器路径

在 Windows 下可以不写第一行注释:

#!/usr/bin/python3

第一行注释标的是指向 python 的路径，告诉操作系统执行这个脚本的时候，调用 /usr/bin 下的 python 解释器。

此外还有以下形式（推荐写法）：

#!/usr/bin/env python3

这种用法先在 env（环境变量）设置里查找 python 的安装路径，再调用对应路径下的解释器程序完成操作。

help()函数

调用 python 的 help() 函数可以打印输出一个函数的文档字符串：

# 如下实例，查看 max 内置函数的参数列表和规范的文档
>>> help(max)
……显示帮助信息……

按下 : q 两个按键即退出说明文档

如果仅仅想得到文档字符串：

>>> print(max.__doc__)    # 注意，doc的前后分别是两个下划线
max(iterable, *[, default=obj, key=func]) -> value
max(arg1, arg2, *args, *[, key=func]) -> value

变量赋值

为多个变量分别赋值

>>> a,b=1,"test"
>>> a
1
>>> b
'test'

多个变量共享同一个内存空间

>>> a=b=1
>>> a
1
>>> b
1
>>> a==b
True

Python3中有六个标准的数据类型：
Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Sets（集合）
Dictionary（字典）


数值的除法（/）总是返回一个浮点数，要获取整数使用//操作符。
>>> 4/2
2.0
>>> 4//2
2
>>> 4//3
1


自然字符串（不考虑转义字符\）， 通过在字符串前加r或R
>>> a=r"this is a line with \n"
>>> a
'this is a line with \\n'


unicode字符串，加前缀u或U
>>> a=u"this is an unicode string, 中国"
>>> a
'this is an unicode string, 中国'


与C字符串不同的是，Python字符串不能被改变。向一个索引位置赋值，比如word[0] = 'm'会导致错误。
>>> a="python"
>>> a[0]
'p'
>>> a[0]="a"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment


创建集合
使用大括号 { } 或者 set() 函数创建集合，创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。


集合运算
print(a - b)     # a和b的差集
print(a | b)     # a和b的并集
print(a & b)     # a和b的交集
print(a ^ b)     # a和b中不同时存在的元素


Python数据类型转换
int(x [,base])
str(x)
chr(x)将一个整数转换为一个字符
ord(x)将一个字符转换为它的整数值
hex(x)将一个整数转换为一个十六进制字符串
oct(x)将一个整数转换为一个八进制字符串
eval(str)用来计算在字符串中的有效Python表达式,并返回一个对象
>>> a=eval("123")
>>> a
123
>>> type(a)
<class 'int'>
>>> a=eval("[1,2,3]")
>>> a
[1, 2, 3]
>>> type(a)
<class 'list'>

list内置函数

list.count(obj) 统计某个元素在列表中出现的次数
list.reverse() 反向列表中元素
list.copy() 复制列表
>>> original_list=[0,1,2,3,4,5,6,7,8]
>>> copy_list=original_list.copy()
>>> copy_list=copy_list+['a','b','c']
>>> print("original_list:",original_list)
original_list: [0, 1, 2, 3, 4, 5, 6, 7, 8]
>>> print("copy_list modify:",copy_list)
copy_list modify: [0, 1, 2, 3, 4, 5, 6, 7, 8, 'a', 'b', 'c']


深拷贝：
import copy
>>> a = [1,2,3,4]
>>> b = a
>>> d = copy.copy(a)
>>> b[0] = 'b'
>>> print(a,b,d)
['b', 2, 3, 4] ['b', 2, 3, 4] [1, 2, 3, 4]
>>> print(id(a),id(b),id(d))
140431253112712 140431253112712 140431253595720

tuple和list一样，只不过元素不能变，tuple存在的意义是可以作为dict的key


dict键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行
dict.copy()

python函数

参数传递：

不可变类型：类似 c++ 的值传递，如 整数、字符串、元组。如fun（a），传递的只是a的值，没有影响a对象本身。比如在 fun（a）内部修改 a 的值，只是修改另一个复制的对象，不会影响 a 本身。
可变类型：类似 c++ 的引用传递，如 列表，字典。如 fun（la），则是将 la 真正的传过去，修改后fun外部的la也会受影响
python 中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。

可更改(mutable)与不可更改(immutable)对象：
在 python 中，strings, tuples, 和 numbers 是不可更改的对象，而 list,dict 等则是可以修改的对象。
不可变类型：变量赋值 a=5 后再赋值 a=10，这里实际是新生成一个 int 值对象 10，再让 a 指向它，而 5 被丢弃，不是改变a的值，相当于新生成了a。
可变类型：变量赋值 la=[1,2,3,4] 后再赋值 la[2]=5 则是将 list la 的第三个元素值更改，本身la没有动，只是其内部的一部分值被修改了。


参数类型：
必需参数
关键字参数
默认参数
不定长参数


匿名函数lambda 

变量作用域
变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。Python的作用域一共有4种，分别是：
L （Local） 局部作用域
E （Enclosing） 闭包函数外的函数中
G （Global） 全局作用域
B （Built-in） 内建作用域
以 L –> E –> G –>B 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。

x = int(2.9)  # 内建作用域
 
g_count = 0  # 全局作用域
def outer():
    o_count = 1  # 闭包函数外的函数中
    def inner():
        i_count = 2  # 局部作用域

Python 中只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如 if/elif/else/、try/except、for/while等）是不会引入新的作用域的，也就是说这这些语句内定义的变量，外部也可以访问，如下代码：

>>> if True:
...  msg = 'I am from Runoob'
... 
>>> msg
'I am from Runoob'
>>> 

如果将 msg 定义在函数中，则它就是局部变量，外部不能访问：

当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了。
以下实例修改全局变量 num：

num = 1
def fun1():
    global num  # 需要使用 global 关键字声明
    print(num) 
    num = 123
    print(num)
fun1() # 输出 1, 123

如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字了，如下实例：

def outer():
    num = 10
    def inner():
        nonlocal num   # nonlocal关键字声明
        num = 100
        print(num)
    inner()
    print(num)
outer() # 输出 100, 100

一种特殊情况：

>>> a = 10
>>> def aa():
...     a = a + 1
...     print(a)
...
>>> aa()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in aa
UnboundLocalError: local variable 'a' referenced before assignment

>>> a
10
>>> def aa():
...  global a
...  a = a + 1
...  print(a)
...
>>> aa()
11

>>> a = 1
>>> def aa():
...  b = a + 2
...  print(b)
...
>>> a
1
>>> aa()
3

模块

一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。

#!/usr/bin/python3
# Filename: using_name.py

if __name__ == '__main__':
   print('程序自身在运行')
else:
   print('我来自另一模块')

运行输出如下：

$ python using_name.py
程序自身在运行

$ python
>>> import using_name
我来自另一模块
>>>