我的Python3学习笔记（1）：python基础

Python基础

数学运算

新旧除法

在新的Python中，使用的不是传统C语言中的地板除，而是用的完整数学意义上的除法。原来的地板除则使用//来代替。

整数

在Python，ruby和Scala中，都可以用int型来表示大数。

标准输入输出

输入

1，raw_input就是用来输入的。

例如：

raw_input("whatyour name ")

这个函数中得到的结果是字符串类型，无论用户输入的是什么类型。

2，input函数，这个函数的使用形似和raw_input一致，但是他要求用户输入的是一个合格的Python表达式，也意味着：在输入字符串的时候必须输入一个“”。这是不可接受的，单数又有一个好处是：input可以判断用户输入的值得类型，这样就可以直接输入int值而不用转换了。

3，在Python3中，把raw_input和input都合并到了同一个input函数中：也就是说现在input函数对于数值和字符串有区分了。

输出

1，在Python 3中，print是一个内置函数，因此在使用的时候要加上括号。

操作符

is和==的区别

"=="是比较内容相当，如变量值相等;"is"是比较对象的id是否相等。这个就像Java中的equal和==，只不过倒过来了。

>>> f1 = 1.0
>>> f2 = 1.0
>>> id(f1)
11372688
>>> id(f2)
11372608
>>> print(f1 == f2)
True
>>> print(f1 is f2)
False

三目运算符

a if b else c

杂项

None

None是唯一的空值。它有着自己的数据类型（NoneType）。可将 None 赋值给任何变量，但不能创建其它 NoneType 对象。所有值为 None 变量是相等的。

None和其他的值比较时都是False。但是在条件判断中None是False。

但是：None== False是False。

通用boolean规则

FalseNone 0 "" () [] {}在boolean环境中是假，其他的都是真。基本上都是Python中内置类型中表示空的值。

注意：他们虽然都表示的是False，但是他们相互之间却并不相等。

注释

Python中的注释使用的是#。

不可变类型

字符串，数值和元组是不可变的，也就是说每次他们被修改的时候其实都是创建了一个新的对象。

 

例如：

>>>name = 'Mrs. Entity'
>>>n = name # This is almost what happens when passing a parameter
>>>n = 'Mr. Gumby' # This is done inside the function
>>>name
'Mrs.Entity'

 

动态语言中的通用作用域

在动态语言中传统的控制结构中没有生成变量域。那么剩下的就只是函数，类和模块可以生成变量作用域了。

Vars

vars函数可以得到当前作用域字典。

访问全局变量

在Python中，有一个严重的问题就是：无法在局部变量中准确判断使用的变量是一个局部变量还是一个全局变量。尤其是给一个全局变量赋值的时候。在这样的情况下，必须再加上其他的规定。

比如如果是简单的引用一个全局变量的值得时候，变量查找会从局部开始查起，如果局部没有就去全局变量查。也就是说：这个时候可以辨清这个是全局还是局部的。

给全局变量赋值

如果要给一个全局变量赋值，那么就要首相声明这是一个全局的变量。Python提供了如下的形式：

>>>x = 1
>>>def change_global():
              global x
              x = x + 1
>>>change_global()
>>>x
2

变量屏蔽

变量屏蔽的问题就是说：局部变量屏蔽了全局变量。这个时候如果想要访问局部变量就会出现问题。

Python中提供了两个函数locals和globals用来得到局部域和全局域，用他们可以轻松访问全局域。

>>>def combine(parameter):
printparameter + globals()['parameter']
...
>>>parameter = 'berry'
>>>combine('Shrub')
Shrubberry

控制结构

If

name= raw_input('What is your name? ')
ifname.endswith('Gumby'):
       if name.startswith('Mr.'):
              print 'Hello, Mr. Gumby'
       elif name.startswith('Mrs.'):
              print 'Hello, Mrs. Gumby'
       else:
              print 'Hello, Gumby'
       else:
              print 'Hello, stranger'

while

name= ''
whilenot name:
name= raw_input('Please enter your name: ')
print 'Hello, %s!' %name

while/True习语

在使用while循环的时候，常常会出现一个情况：必须设定一个变量，以使得while循环可以有判断条件。

例如：

word= 'dummy'
whileword:
       word = raw_input('Please enter a word: ')
       # do something with the word:
       print 'The word was ' + word

这儿在while外面设定了一个while循环，使得代码不够优雅。因此使用while/True习语。

 

如下：

whileTrue:
              word = raw_input('Please enter aword: ')
              if not word: break
              # do something with the word:
              print 'The word was ' + word

for

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for number in numbers:
              printnumber

结合range可以用来遍历一个数值。

遍历字典

d ={'x': 1, 'y': 2, 'z': 3}
forkey in d:
              print key, 'corresponds to', d[key]

并行迭代

forname, age in zip(names, ages):
              print name, 'is', age, 'years old'

跳出循环

       有break和continue。

With

with实现的是一种资源借贷的方法，如下：

withopen(filename) as f:
   input = f.read()
output= do_something(input)
withopen(filename, 'w') as f:
   f.write(output)

这个方式就是使用一个有__enter__和__exit__函数的对象来管理资源，__enter__来得到资源，__exit__处理这个资源的善后工作。得到这个对象的方法有两种：使用一个方法放回一个对象或者直接创建一个对象。

with对象

实现一个类__enter__（）和__exit__()方法

class controlled_execution:
    def _enter__(self):
        set things up
        return thing
    def __exit__(self, type, value,  traceback):
        tear thing down
with controlled_execution() as thing:
    some code

在实际的运行过程中，python会首先运行enter里的代码，返回thing，作为as 后面的变量值，然后再运行with模块中的代码，最后会自动执行exit中的代码，而不管with中的代码运行结果如何。这也就是with能简化try-finally语句的原因。所以with通常用在读取文件的操作中，将文件句柄的关闭操作放在exit方法中，这样就不会因忘记释放文件句柄而产生可能出现的错误。

函数

withopen('a.txt') as f:
print f.readlines()

列表解析

列表解析是一种使用原来的列表来建立新的列表的方法。

>>>[x*x for x in range(10)]
[0, 1, 4, 9, 16, 25, 36,49, 64, 81]

添加守卫

守卫就是一个if语句，用来决定这个列表值是否应该放到这个结果列表里面。

>>>[x*x for x in range(10) if x % 3 == 0]
[0, 9, 36, 81]

多个列表同时解析

>>>[(x, y) for x in range(3) for y in range(3)]
[(0, 0), (0, 1), (0, 2),(1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

循环生成器

循环生成器和列表解析类似，只是他实际上产生的是一个迭代的对象。每次调用这个对象的next方法可以得到下一个列表解析中的值。

 

>>>g = ((i+2)**2 for i in range(2,27))
>>>g.next()
16

 

如同列表解析一样，循环生成器也可以直接用于和列表一起工作的函数。

sum(i**2 for i inrange(10))

基础特性

并行赋值

并行赋值，在底层使用的是元组

>>>x, y, z = 1, 2, 3
>>>print x, y, z
1 2 3
 

例如:

>>>values = 1, 2, 3
>>>values
(1,2, 3)
>>>x, y, z = values
>>>x
1

多返回值

借助于并行赋值，Python可以实现函数的多个返回值。

>>>scoundrel = {'name': 'Robin', 'girlfriend': 'Marion'}
>>>key, value = scoundrel.popitem()
>>>key
'girlfriend'
>>>value
'Marion'

Pass

Python中的pass用作空语句。

Del

del删除的是引用，不是真正的对象。

>>>x = ["Hello", "world"]
>>>y = x
>>>y[1] = "Python"
>>>x
['Hello', 'Python']

Exec

exec执行的时候会影响当前的空间。

>>>from math import sqrt
>>>exec "sqrt = 1"
>>>sqrt(4)
Traceback(most recent call last):
File"<pyshell#18>", line 1, in ?
sqrt(4)
TypeError:object is not callable: 1

 

如果不让它影响命名空间，可以使用in <scope>语句。

>>>from math import sqrt
>>>scope = {}
>>>exec 'sqrt = 1' in scope
>>>sqrt(4)
2.0
>>>scope['sqrt']
1

这样exec就是在我们制定的空间中执行的。注意：由于scope这个字典中还有__builtins__这个命名空间，因此除了防止命名冲突以外。其他的木有什么不同。

例如：

>>>len(scope)
2
>>>scope.keys()
['sqrt', '__builtins__']