我的 Python 快速入门 | 隔叶黄莺 Yanbin Blog

2016-06-27 | 阅读(503)

本文只是我个人的掌握 Python 的快速入门笔记, 所以混乱不堪, 并不适合于每一个想要学习 Python 的读者

Python 命令进到它的 shell, ctrl+d 或 exit() 退出 python. help(str) 可以查看 str 函数的帮助, q 退出帮助. 对象的方法可用 dir 来查看, dir([]), dir(""), 进而 help([].append), help(dir([]))

Python 是用严格的缩进来格式化代码块的, Google 的 Python 代码规范是用 4 个空格来缩进. Google 建议 Java 是用两个空格.

Python 是动态类型的, 所以可以 a = 1; a = "string" 随意赋值为不同类型. Python 也能用分号把多条语句写在同一行里, 但基本没人用分号的.
Python 的基本类型有整数, 长整数, 浮点数和复数, 以及字符串

字符串可以用单引号和双引号, 它们像 Javascript, 是完全一样的
''' 或 "”” 三引号的字符串是 here doc, 多行字符串
转义符也是用 \, 如 ''What\’s your name\n?
自然字符串: 即不转义, 用 R 或 r 来指定, 如 r"Newlines are indicated by \n”, 会输出 "\n"" 字面值. 可用于书写正则表达式
放在一起的字符串就会被 Python 自动连接, 如 print ''What\'s' ''your name?’, 输出为 "What’s your name?”

Python 的命名规则有几个必须知道的: 类名和 Java 一样; 模块, 方法, 变量名用小写字母下划线分隔, 常量用大写加下划线. 单或双下划线开头是特殊用途. 命名规则请参考 Google Python Style Guide#Naming
Python 是纯面向对象的, 任何东西都是对象, 函数也是

Python 可以用 \ 来连接语句行, 像 Bash 一样, 如

print "This is\
me"

print 1 +\
    3

print "This is\

me"

print 1 +\

大部分的操作符都和 Java 一样的, 算述, 移位, 逻辑操作等. 特别的运算符有 ** 和 //

** 幂
// 取整除, 返回商的整数部分
Python 也像 Scala 那样不支持 ++ 和 — 操作, 至于运算符的优先级没必要这么清楚的, 有括号总比没括号可读性强

控制流

条件语句:

if a > 1:
    print "larger"
elif a < 1:
    print "smaller"
else:
    print "equal"

if a > 1:

print "larger"

elif a < 1:

print "smaller"

else:

print "equal"

Python 没有 switch/case 语句

循环语句: while 和 for..in

while true:
    #do something

1 2	while true: #do something

for..in, Python 只支持这种格式的 for 循环

for i in range(1, 5):
    print i
else:
    print ''The for loop is over’ #循环正常结束会执行这行, 除非遇到了 break 语名

for i in range(1, 5):

print i

else:

print ''The for loop is over’ #循环正常结束会执行这行, 除非遇到了 break 语名

Python 也可以用 break 和 continue 结束整个或当前循环

什么也不做的 pass 语句

pass 语句更像是一个占位符，有点像 Java 的 ; 分号，如

while True:
    pass

class MyEmptyClass:
    pass

def initlog(*args):
    pass

while True:

pass

class MyEmptyClass:

pass

def initlog(*args):

pass

函数定义用 def 关键字, 这和很多语言一样的

def say(message):
    print message

1 2	def say(message): print message

方法体中没有用 global 定义的变量是局部变量. 有 global 修饰, 如 global x = 100, 或 global x, y, z 是全局变量, 像 Javascript 中没有用 var 修饰一样. 和 PHP 一样, 如果在某个方法中需要使用全局变量, 也必须用 global x 声明一下, 否则是一个局部变量.

Python 函数支持默认参数

def fun(a, b=5, c=10):
    print 'a is’, a, ''and b is’, b, ''and c is ', c #可见 print 也可以接受多个参数

fun(3, 7)
fun(25, c=24)
fun(c=50, a=100)

def fun(a, b=5, c=10):

print 'a is’, a, ''and b is’, b, ''and c is ', c #可见 print 也可以接受多个参数

fun(3, 7)

fun(25, c=24)

fun(c=50, a=100)

为了调用的参数按序匹配, 和其他语言(Scala) 一样, 带默认值的参数要写在后面. Python 不支持方法的重载, 默认参数方式在一定程度上支持了重载.

Python 函数也支持可变参数，类似 Java 的 VarArg 语法

def write_multiple_items(file, separator, *args):
    file.write(separator.join(args))

1 2	def write_multiple_items(file, separator, *args): file.write(separator.join(args))

方法的返回值要显式的用 return 语句, 和 Java 一样的. 每个函数都在结尾暗含有 return None 语句, None 是 Python 里的 null, 表示没有. 如

def sayHello():
    print ''Hello'

print sayHello() #输出为 None

def maximum(x, y):
    if x > y:
        return x

print maximum(1, 3) #输出也为 None

def sayHello():

print ''Hello'

print sayHello() #输出为 None

def maximum(x, y):

if x > y:

return x

print maximum(1, 3) #输出也为 None

Python 的 DocStrings 是类似于 JavaDoc 的东西, 但它是写在类或函数体中第一个字符串, 一般用一个多行字符串, 它的惯例是首行以大写字母开始, 句号结层. 第二行空行, 第三行详细描述. help() 就是抓取这个 doc string

def printMax(x, y):
    '''Prints the maximum of two numbers.

    The two values must be integers.'''
    #……..

print printMax.__doc___ #显示上面函数中第一个字符品的内容

def printMax(x, y):

'''Prints the maximum of two numbers.

The two values must be integers.'''

#……..

print printMax.__doc___ #显示上面函数中第一个字符品的内容

Python 的 Lambda 形式，怎么少了这么典型的函数式编程风格呢。Python 的 Lambda 需要显式的用 lambda 关键字，简单例子如下：

>>> f = lambda x, y: x + y
>>> f(2, 3)
5

>>> f = lambda x, y: x + y

>>> f(2, 3)

Python 的模块与 Javascript 里模块的概念是一样的. 模块是包含了所定义的函数和变量的文件, 模块文件名必须以 .py 为扩展名.

import user 会从 sys.path 中查找 user.py 文件, 并且只在第一次导入时会执行模块 user 主块中的代码, 主块就是那些未定义在函数中的代码

import sys; print sys.path 可以查看加载模块的所有路径, 先在当前目录中查找

#filename: user.py

if __name__ == '__main__':
    print 'This program is being run by itself'
else:
    print __name__
    print 'I am being imported from another module'

#filename: user.py

if __name__ == '__main__':

print 'This program is being run by itself'

else:

print __name__

print 'I am being imported from another module'

$ python user.py
This program is being run by itself

$ python
>>> import user
user
I am being imported from another module
>>> import user
>>>

$ python user.py

This program is being run by itself

$ python

>>> import user

user

I am being imported from another module

>>> import user

>>>

user 模块第一次被输入时会执行不在任何函数(即主块中)的代码, python user.py 时模块的 name 是 "__main__”, import 时是 "user"

#filename: user.py

import datetime

def sayhi():
    print 'Hi, this is my module speaking'

now = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')

#filename: user.py

import datetime

def sayhi():

print 'Hi, this is my module speaking'

now = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')

---
import 语句,

import user
user.sayhi()
print user.now

import user

user.sayhi()

print user.now

from…import 语句(有节制的使用用这种方式)

from user import sayhi #有点像 Java 的静态引入, 但不能使用 user.sayhi() 了
sayhi() #不能用 user.sayhi()

1 2	from user import sayhi #有点像 Java 的静态引入, 但不能使用 user.sayhi() 了 sayhi() #不能用 user.sayhi()

Python 的 import, from…import 和 Javascript 的很相似; import 还可以指定别名, 如

import user as u
u.sayhi()

1 2	import user as u u.sayhi()

Python 的包

模块的上一层组织形式是包，我们在 import a.b.c 时，a.b 就是包，c 是包或模块，用类似 Java 一样的目录结构

sound/
__init__.py //每个包只必须含有这个文件，才能让 Python 识别为包，它可以是空的，也能做些初始化，如 __all__ 变量
formats/
__init__.py
echo.py

那么引用就是 import sound.formats.echo

Python 的基本数据结构

列表: shoplist = [''apple", ''mango", ''carrot"]
操作: shoplist.append(''rice"); shoplift.sort(); for item in shoplift: ….; del shoplist[0]
切片操作: shoplist[1:3], shoplist[2:], shoplist[:], shoplist[-1] ….
列表的赋值不创建拷贝, 必须用上面的切片方法来获得列表的拷贝

元组: zoo = (''wolf", ''elephant", ''penguin")
操作: len(zoo); zoo[0] 也是像列表那样用数字索引来访问

Python 格式化字符串输出, % 和元组或单个变量, 如

age = 22
name = 'Swaroop'

print '%s is %d years old' % (name, age)
print 'Why is %s playing with that python?' % name

age = 22

name = 'Swaroop'

print '%s is %d years old' % (name, age)

print 'Why is %s playing with that python?' % name

字典: d = {''key1': value1, ''key2': value2}; d[''key1’]

一个Python 调用系统命令的例子

import os

if os.system('ls -l') == 0:
    print 'Sucessful'
else:
    print 'Failed'

import os

if os.system('ls -l') == 0:

print 'Sucessful'

else:

print 'Failed'

控制台会直接打印出 "ls -l” 命令的输出, 不需要去手动捕获系统命令的输出

Python 中真正面向对像编程还得靠 class, 下边是一个 Python class 的例子

# -*- coding: utf-8 -*-

class Person:
    '''Represents a person.'''

    population = 0 #类变量

    def __init__(self, name): # 构造函数
        '''Initializes the person's data.'''
        self.name = name #self.name 是实例变量
        Person.population += 1

    def __del__(self): # 析构函数
        '''I am dying.'''
        print '%s says bye.' % self.name
        Person.population -= 1

    def say_hi(self): # 实例方法
        self.__xyz()
        print 'Hi, my name is %s.' % self.name

    def __xyz(self):
        print 'private method'

    @classmethod
    def how_many(cls): #类方法, 类方法与静态方法的区别 https://www.zhihu.com/question/20021164
        print 'There are %s people' % Person.population

p1 = Person('Yanbin') #当构造函数没有参数的时候，括号也必须的， new Person()
print 'name:', p1.name
p1.say_hi()

p1.how_many() #和 Java 一样也能通过实例来调用类方法
Person.how_many()
# p1.__xyz() 双下划线的变量或方法为私有的

# -*- coding: utf-8 -*-

class Person:

'''Represents a person.'''

population = 0 #类变量

def __init__(self, name): # 构造函数

'''Initializes the person's data.'''

self.name = name #self.name 是实例变量

Person.population += 1

def __del__(self): # 析构函数

'''I am dying.'''

print '%s says bye.' % self.name

Person.population -= 1

def say_hi(self): # 实例方法

self.__xyz()

print 'Hi, my name is %s.' % self.name

def __xyz(self):

print 'private method'

@classmethod

def how_many(cls): #类方法, 类方法与静态方法的区别 https://www.zhihu.com/question/20021164

print 'There are %s people' % Person.population

p1 = Person('Yanbin') #当构造函数没有参数的时候，括号也必须的， new Person()

print 'name:', p1.name

p1.say_hi()

p1.how_many() #和 Java 一样也能通过实例来调用类方法

Person.how_many()

# p1.__xyz() 双下划线的变量或方法为私有的

Python 中默认成员都是 public, 双下划线开始的变量或方法就是私有的

类的继承方式用 class SubClass(SuperClass), Python 居然还允许多重继承: class SubClass(SuperClass1, SuperClass2, …)

Python 的异常处理

Python 的异常是 Error 或 Exception 类的直接或间接实例

class CustomException(Exception):
    def __init__(self, code):
    self.code = code
try:
    raise CustomException(3) #in some case
except EOFError:
    print 'EOF occurs'
except CustomException, x:
    print x.message, x.code
except:
    print 'any other exception'
finally:
    print 'happens in any case'

class CustomException(Exception):

def __init__(self, code):

self.code = code

try:

raise CustomException(3) #in some case

except EOFError:

print 'EOF occurs'

except CustomException, x:

print x.message, x.code

except:

print 'any other exception'

finally:

print 'happens in any case'

本文归纳自: http://wiki.jikexueyuan.com/project/simple-python-course/ 还有 Python 入门指南

M	T	W	T	F	S	S
						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