欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

Learn Python in Y minutes

程序员文章站 2023-12-23 12:50:22
...

注:
来自 https://learnxinyminutes.com/docs/python3/http://learnxinyminutes.com/docs/python/

Python是Guido Van Rossum在90年代发明的。它是目前最热闹的编程语言之一。

原始数据类型与操作

数值型

# 数值型
3 # => 3

# 数学计算
1 + 1 # => 2
8 - 1 # => 7
10 * 2 # => 20
35 / 5 # => 7

# 整型(int)的除法只会获得整型结果,余数自动舍弃 Python 2.7
5 / 2 # => 2
# Python会自动返回浮点数
5 / 2 # => 2.5

# 浮点型(float)的计算可以有小数
2.0 # 这是一个浮点型
11.0 / 4.0 # => 2.75

# 如果只需要整数部分,使用"//"做除法,又叫地板除(foored division)
5 // 3 # => 1
5.0 // 3.0 # => 1.0 浮点型效果也一样
-5 // 3 # => -2
-5.0 // 3.0 # => -2.0

# 取余操作
7 % 3 # => 1

# 幂操作
2 ** 4 # => 16

# 使用括号改变优先级
(1+3) * 2 # => 8

布尔型

# 注: "and" 和 "or" 都是大小写敏感的
True and False # => False
False or True # => True

# 注:int型也可以使用布尔操作
0 and 2 # => 0
-5 or 0 # => -5
0 == False # => True
2 == True # => False
1 == True # => True

# 非操作
not True # => False
not False # => True

# 判断相等
1 == 1 # => True
2 == 1 # => False

# 判断不相等
1 != 1 # => False
2 != 1 # => True

# 其它比较操作
1 < 10 # => True
1 > 10 # => False
2 <= 2 # => True
2 >= 2 # => True

# 比较操作可以串联
1 < 2 < 3 # => True
1 < 3 < 2 # => False

# is 与 == 比较
# is 是判断两个变量是否引用了同一个类
# == 是判断两个变量是否有同样的值
a = [1, 2, 3, 4]  # 将 a 指向一个新的数组 [1, 2, 3, 4]
b = a             # 将 b 指向 a 所指向的对象
b is a            # => True, a 和 b 引用了同一个对象
b == a            # => True, a 和 b 的对象值也相同
b = [1, 2, 3, 4]  # 将 b 指向一个新的数组 [1, 2, 3, 4]
b is a            # => False, a 和 b 不是引用了同一个对象
b == a            # => True, a 和 b 的对象值相同

字符串

# 字符串使用 单引号 或者 双引号 表示
"这是一个字符串"
'这也是一个字符串'

# 字符串可以使用"+"连接
"Hello " + "world!" # "Hello world!"
# 不使用"+"也可以让字符串连接
"Hello " "world!" # "Hello world!"

# 字符串乘法
"Hello" * 3 # => "HelloHelloHello"

# 字符串可以当作字符数组操作
"This is a string"[0] # => "T"

# 使用 % 对字符串进行格式化
# 从Python 3.1 开始已经不推荐使用了,但了解一下如何使用还是有必要的
x = 'apple'
y = 'lemon'
z = "The items in the basket are %s and %s " % (x,y)

# 新的格式化字符串的方式是使用format方法
"{} is a {}".format("This", "placeholder")
"{0} can be {1}".format("strings", "formatted")
# 如果不想用下标方式,可以使用关键字的方式
"{name} wants to eat {food}".format(name="Bob", food="lasagna")

其它

# None 是一个对象
None # => None

# 如果想要将一个对象与None进行比较,使用 is 而不要使用 == 符号
"etc" is None # => False
None is None # => True

# is 操作用来判断对象的类型。在对象操作时非常有用

# 任何一个对象都可以放在一个布尔上下文中进行判断
# 下面的情况会被当作False
#   - None
#   - 值为0的任何数值类型,(例如,0,0L,0.0,0j)
#   - 空列表,(例如,'',(),[])
#   - 空的容器,(例如,{},set())
#   - 符合条件的用户自定义对象实例,参看:https://docs.python.org/2/reference/datamodel.html#object.__nonzero__
#
# 其它情况下的值会被当作True,可以使用bool()函数来判断
bool(0)   # => False
bool("")  # => False
bool([])  # => False
bool({})  # => False

变量与集合

输入输出

# Python有一个打印语句
print "I'm Python. Nice to meet you!" # => I'm Python. Nice to meet you!

# 获取控制台输入的简单方法
input_string_var = raw_input("Enter some data: ") # 返回字符串类型的数据
input_var = input("Enter some data: ") # 返回数值型的数据
# Warning: Caution is recommended for input() method usage
# 注意:在Python3中,input()已经不再使用,raw_input()重命名为input()

# 不需要先声明变量再使用
some_var = 5    # 通常使用小写字母与下划线命名变量
some_var  # => 5

# 访问一个未定义的变量会抛出一个异常
# 在“控制流”里会介绍更多异常处理
some_other_var  # 这里会抛出一个NameError

# if 可以用来写成类似C语言的 '?:' 条件表达式
"yahoo!" if 3 > 2 else 2  # => "yahoo!"

列表(List)

# List用来存储列表
li = []
# 可以有初始数据
other_li = [4, 5, 6]

# 添加元素到列表的尾
li.append(1) # [1]
li.append(2) # [1,2]
li.append(4) # [1,2,4]
li.append(3) # [1,2,4,3]
# 使用pop方法移除列表末尾的元素
li.pop()        # => 3 列表现在为 [1, 2, 4]
# 把3再放回去
li.append(3)    # li 现在为 [1, 2, 4, 3]

# 像数组一样访问一个list
li[0]  # => 1
# 通过下标重新定义一个元素的值
li[0] = 42
li[0]  # => 42
li[0] = 1  # 注意:设置回原始值
# 查看最后一个元素
li[-1]  # => 3

# 查找超过数据长度的值会抛出异常: IndexError
li[4]  # 抛出 IndexError

# 可以使用切片句法访问列表
# 这里类型数学上的开/闭区间
li[1:3]  # => [2, 4]
li[2:]  # => [4, 3]
li[:3]  # => [1, 2, 4]
li[::2]   # =>[1, 4]
li[::-1]   # => [3, 4, 2, 1]
# 使用高级切片句法
# li[start:end:step]

# 使用切片进行深层拷贝
li2 = li[:]  # => li2 = [1, 2, 4, 3] 但 (li2 is li) 返回 false


# 使用“del”直接从列表中删除元素
del li[2] #liisnow[1,2,3]

# 可以直接添加一个列表
li+other_li #=>[1,2,3,4,5,6]
# 注: 变量li 和 other_li 值并没有变化

# 使用extend()方法,把列表串起来
li.extend(other_li)   # Now li is [1, 2, 3, 4, 5, 6]

# 删除第一个值与参数相同的元素
li.remove(2)  # li is now [1, 3, 4, 5, 6]
li.remove(2)  # 抛出异常 ValueError 列表中没有2

# 在指定下标插入元素
li.insert(1, 2)  # li is now [1, 2, 3, 4, 5, 6] again

# 获得第一个匹配的元素的下标
li.index(2)  # => 1
li.index(7)  # 抛出异常 ValueError 列表中没有7

# 使用“in”来检查列表中是否包含元素
1 in li #=>True
# 使用“len()”来检查列表的长度
len(li)   # => 6

元组(Tuple)

# 元组(Tuple)与列表类似但不可修改
tup = (1, 2, 3)
tup[0]   # => 1
tup[0] = 3  # 抛出异常 TypeError

# 注意:如果一个元组里只有一个元素,则需要在元素之后加一个逗号;如果元组里没有元素,反而不用加逗号
type((1))   # => <class 'int'>
type((1,))  # => <class 'tuple'>
type(())    # => <class 'tuple'>

# 以下对列表的操作,也可以用在元组上
len(tup) # => 3
tup+(4,5,6) #=>(1,2,3,4,5,6)
tup[:2] #=>(1,2)
2intup #=>True

# 可以把元组的值分解到多个变量上
a,b,c= (1, 2, 3) #a is now 1,b  is now 2 and c is now 3
d,e,f= 4,5,6 # 也可以不带括号
# 如果不带括号,元组会默认带上
g = 4, 5, 6 #=>(4,5,6)
# 非常容易实现交换两个变量的值
e, d = d, e # d is now 5 and e is now 4

字典(Dictionaries)

# 字典用来存储(键-值)映射关系
empty_dict = {}
# 这里有个带初始值的字典
filled_dict = {"one": 1, "two": 2, "three": 3}

# 注意:字典 key 必须是不可以修改类型,以确保键值可以被哈希后进行快速检索
# 不可修改的类型包括:int, float, string, tuple
invalid_dict = {[1,2,3]: "123"}  # => Raises a TypeError: unhashable type: 'list'
valid_dict = {(1,2,3):[1,2,3]}   # Values can be of any type, however.

# 使用[]查找一个元素
filled_dict["one"]   # => 1
# 使用"keys()"获得所有的“键”
filled_dict.keys()   # => ["three", "two", "one"]
# 注:字典的key是无序的,结果可以不匹配
# 使用"values()"获得所有的“值”
filled_dict.values()   # => [3, 2, 1]
# 注:同样,这是无序的
# 查询字条中是否存在某个”键“用 "in"
"one" in filled_dict   # => True
1 in filled_dict   # => False
# 查找一个不存在的key会抛出异常 KeyError
filled_dict["four"]   # KeyError
# 使用 "get()" 会避免抛出异常 KeyError
filled_dict.get("one") # => 1
filled_dict.get("four") # => None
# get方法支持默认参数,当key不存在时返回该默认参数
filled_dict.get("one", 4) #=>1
filled_dict.get("four", 4)   # => 4
# 注 filled_dict.get("four") 仍然返回 None
# (get不会把值插入字典中)
# 向字典中插入值的方式与list相同
filled_dict["four"] = 4  # now, filled_dict["four"] => 4
# "setdefault()" 只有首次插入时才会生效
filled_dict.setdefault("five", 5)  # filled_dict["five"] is set to 5
filled_dict.setdefault("five", 6)  # filled_dict["five"] is still 5

# 使用 del 从字典中删除一个键
del filled_dict["one"]  # Removes the key "one" from filled dict

# 从 Python 3.5 开始,可以使用**操作
{'a': 1, **{'b': 2}}  # => {'a': 1, 'b': 2}
{'a': 1, **{'a': 2}}  # => {'a': 2}

集合(Set)

# Set与list类似,但不存储重复的元素
empty_set = set()
some_set = set([1, 2, 2, 3, 4])   # some_set is now set([1, 2, 3, 4])

# 与字典类型一样,Set 里的元素也必须是不可修改的
invalid_set = {[1], 1}  # => Raises a TypeError: unhashable type: 'list'
valid_set = {(1,), 1}

# Set也是无序的,尽管有时看上去像有序的
another_set = set([4, 3, 2, 2, 1])  # another_set is now set([1, 2, 3, 4])
# 从Python 2.7开妈, {}可以用来声明一个Set
filled_set={1,2,2,3,4} #=>{1,2,3,4}
# Can set new variables to a set
filled_set = some_set
# 向Set中添加元素
filled_set.add(5)   # filled_set is now {1, 2, 3, 4, 5}
# 用 & 求 Set的交集
other_set = {3, 4, 5, 6}
filled_set & other_set # =>{3,4,5}
# 用 | 求 Set的合集
filled_set | other_set # =>{1,2,3,4,5,6}
# Do set difference with - 
{1,2,3,4}-{2,3,5} # => {1,4}
# Do set symmetric difference with ^ 
{1,2,3,4}^{2,3,5} #=>{1,4,5}
# 检查右边是否是左边的子集
{1, 2} >= {1, 2, 3} # => False
# 检查左边是否是右边的子集
{1, 2} <= {1, 2, 3} # => True
# 检查元素是否在集合中
2 in filled_set   # => True
10 in filled_set   # => False

控制流

分支结构

# 先定义一个变量
some_var = 5
# 这里用到了if语句 缩进是Python里的重要属性
# 打印 "some_var is smaller than 10"
if some_var > 10:
    print "some_var is totally bigger than 10."
elif some_var < 10:    # This elif clause is optional.
    print "some_var is smaller than 10."
else:           # This is optional too.
    print "some_var is indeed 10."

循环结构

# For 循环用来遍历一个列表
for animal in ["dog", "cat", "mouse"]:
    # 使用{0}格式 插入字符串
    print "{0} is a mammal".format(animal)

# "range(number)" 返回一个包含数字的列表
for i in range(4):
print i

# "range(lower, upper)" 返回一个从lower数值到upper数值的列表
for i in range(4, 8):
print i

# "range(lower, upper, step)" 返回一个从lower数值到upper步长为step数值的列表
# step 的默认值为1
for i in range(4, 8, 2):
    print(i)
# While 循环会一致执行下去,直到条件不满足
x=0
while x < 4:
print x
x+=1 #x=x+1的简写

异常处理

# 使用 try/except 代码块来处理异常
# 自 Python 2.6 以上版本支持:
try:
    # 使用 "raise" 来抛出一个异常
    raise IndexError("This is an index error")
except IndexError as e:
    pass    # Pass 表示无操作. 通常这里需要解决异常.
except (TypeError, NameError):
    pass    # 如果需要多个异常可以同时捕获
else:   # 可选项. 必须在所有的except之后
    print "All good!"   # 当try语句块中没有抛出异常才会执行
finally: #  所有情况都会执行
    print "We can clean up resources here"

# with 语句用来替代 try/finally 简化代码
with open("myfile.txt") as f:
    for line in f:
        print line

迭代器

# Python offers a fundamental abstraction called the Iterable.
# An iterable is an object that can be treated as a sequence.
# The object returned the range function, is an iterable.

filled_dict = {"one": 1, "two": 2, "three": 3}
our_iterable = filled_dict.keys()
print(our_iterable)  # => dict_keys(['one', 'two', 'three']). This is an object that implements our Iterable interface.

# We can loop over it.
for i in our_iterable:
    print(i)  # Prints one, two, three

# However we cannot address elements by index.
our_iterable[1]  # Raises a TypeError

# An iterable is an object that knows how to create an iterator.
our_iterator = iter(our_iterable)

# Our iterator is an object that can remember the state as we traverse through it.
# We get the next object with "next()".
next(our_iterator)  # => "one"

# It maintains state as we iterate.
next(our_iterator)  # => "two"
next(our_iterator)  # => "three"

# After the iterator has returned all of its data, it gives you a StopIterator Exception
next(our_iterator)  # Raises StopIteration

# You can grab all the elements of an iterator by calling list() on it.
list(filled_dict.keys())  # => Returns ["one", "two", "three"]

函数

# 使用 "def" 来创建一个新的函数
def add(x, y):
    print "x is {0} and y is {1}".format(x, y)
    return x + y    # 用 return 语句返回值
# 调用函数
add(5,6) #=>prints out "x is 5 and y is 6" 返回值为11
# 使用关键字参数调用函数
add(y=6, x=5)   # 关键字参数可以不在乎参数的顺序
# 函数的参数个数可以不定,使用*号会将参数当作元组
def varargs(*args):
    return args
varargs(1, 2, 3)   # => (1, 2, 3)

# 也可以使用**号将参数当作字典类型
def keyword_args(**kwargs):
    return kwargs
  # 调用一下试试看
keyword_args(big="foot", loch="ness") # => {"big": "foot", "loch": "ness"}

# 两种类型的参数可以同时使用
def all_the_args(*args, **kwargs):
    print args
    print kwargs
"""
all_the_args(1, 2, a=3, b=4) prints:
    (1, 2)
    {"a": 3, "b": 4}
"""

# When calling functions, you can do the opposite of args/kwargs!
# Use * to expand positional args and use ** to expand keyword args.
args = (1, 2, 3, 4)
kwargs = {"a": 3, "b": 4}
all_the_args(*args)   # 相当于 foo(1, 2, 3, 4)
all_the_args(**kwargs)   # 相当于 foo(a=3, b=4)
all_the_args(*args, **kwargs)   # 相当于 foo(1, 2, 3, 4, a=3, b=4)
# you can pass args and kwargs along to other functions that take args/kwargs
# by expanding them with * and ** respectively
def pass_all_the_args(*args, **kwargs):
    all_the_args(*args, **kwargs)
    print varargs(*args)
    print keyword_args(**kwargs)

# Returning multiple values (with tuple assignments)
def swap(x, y):
    return y, x  # Return multiple values as a tuple without the parenthesis.
                 # (Note: parenthesis have been excluded but can be included)

x = 1
y = 2
x, y = swap(x, y)     # => x = 2, y = 1
# (x, y) = swap(x,y)  # Again parenthesis have been excluded but can be included.

函数的作用域

x=5
def set_x(num):
    # 局部变量x与全局变量x不相同
    x = num # => 43
    print x # => 43
def set_global_x(num):
    global x
    print x # => 5
    x = num # 全局变量被设置成为6
    print x # => 6
set_x(43)
set_global_x(6)
# 函数也可以是对象
def create_adder(x):
    def adder(y):
        return x + y
return adder
add_10 = create_adder(10)
add_10(3)   # => 13
# 匿名函数
(lambda x: x > 2)(3)   # => True
(lambda x, y: x ** 2 + y ** 2)(2, 1) # => 5
# 高阶函数
map(add_10, [1, 2, 3])   # => [11, 12, 13]
map(max, [1, 2, 3], [4, 2, 1])   # => [4, 2, 3]
filter(lambda x: x > 5, [3, 4, 5, 6, 7])   # => [6, 7]
# We can use list comprehensions for nice maps and filters
[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13]
[x for x in[3,4,5,6,7] if x>5] #=>[6,7]

# 继承 object 创建一个子类
class Human(object):
    # 一个类属性,所有该类的实例都可以访问
    species = "H. sapiens"
    # 基础实例化方法,在创建一个实例时调用
    # 注意在名称前后加双下划线表示对象或者属性是 Python 的特殊用法,但用户可以自己控制
    # 最好不要在自己的方法前这样使用
    def __init__(self, name):
        # 将参数赋值给实例属性
        self.name = name
        # 初始化属性
        self.age = 0
    # 一个实例方法。所有实例方法的第一个属性都是self
    def say(self, msg):
        return "{0}: {1}".format(self.name, msg)

    # A class method is shared among all instances
    # They are called with the calling class as the first argument
    @classmethod
    def get_species(cls):
        return cls.species 

    # A static method is called without a class or instance reference
    @staticmethod
    def grunt():
        return "*grunt*"

    # A property is just like a getter.
    # It turns the method age() into an read-only attribute
    # of the same name.
    @property
    def age(self):
        return self._age

    # This allows the property to be set
    @age.setter
    def age(self, age):
        self._age = age

    # This allows the property to be deleted
    @age.deleter
    def age(self):
        del self._age

# 创建一个实例
i = Human(name="Ian")
print i.say("hi") # prints out "Ian: hi"

j = Human("Joel")
print j.say("hello")  # prints out "Joel: hello"

# 调用类方法
i.get_species()   # => "H. sapiens"

# 访问共有变量
Human.species = "H. neanderthalensis"
i.get_species()   # => "H. neanderthalensis"
j.get_species()   # => "H. neanderthalensis"

# 调用静态方法
Human.grunt()   # => "*grunt*"

# Update the property
i.age = 42

# Get the property
i.age # => 42

# Delete the property
del i.age
i.age  # => raises an AttributeError

模块

# 可以直接引用其它模块
import math
print math.sqrt(16)  # => 4
# 也可以引用模块中的函数
from math import ceil, floor
print ceil(3.7)  # => 4.0
print floor(3.7)   # => 3.0

# 你可以引用一个模块中的所有函数
# 警告:这是不推荐的
from math import *
# 可以给模块起个简短的别名
import math as m
math.sqrt(16) == m.sqrt(16)   # => True
# you can also test that the functions are equivalent
from math import sqrt
math.sqrt == m.sqrt == sqrt  # => True
# Python modules are just ordinary python files. You
# can write your own, and import them. The name of the
# module is the same as the name of the file.
# You can find out which functions and attributes
# defines a module.
import math
dir(math)

高级

# Generators help you make lazy code
def double_numbers(iterable):
    for i in iterable:
        yield i + i
# A generator creates values on the fly.
# Instead of generating and returning all values at once it creates one in each
# iteration.  This means values bigger than 15 wont be processed in
# double_numbers.
# Note xrange is a generator that does the same thing range does.
# Creating a list 1-900000000 would take lot of time and space to be made.
# xrange creates an xrange generator object instead of creating the entire list
# like range does.
# We use a trailing underscore in variable names when we want to use a name that
# would normally collide with a python keyword
xrange_ = xrange(1, 900000000)
# will double all numbers until a result >=30 found
for i in double_numbers(xrange_):
    print i
    if i >= 30:
break 
# Decorators
# in this example beg wraps say
# Beg will call say. If say_please is True then it will change the returned
# message
from functools import wraps

def beg(target_function):
    @wraps(target_function)
    def wrapper(*args, **kwargs):
        msg, say_please = target_function(*args, **kwargs)
        if say_please:
            return "{} {}".format(msg, "Please! I am poor :(")
        return msg
    return wrapper
@beg
def say(say_please=False):
    msg = "Can you buy me a beer?"
    return msg, say_please
print say()  # Can you buy me a beer?
print say(say_please=True)  # Can you buy me a beer? Please! I am poor :(

Free Online

Automate the Boring Stuff with Python (https://automatetheboringstuff.com)

Learn Python The Hard Way (http://learnpythonthehardway.org/book/)

Dive Into Python (http://www.diveintopython.net/)

Ideas for Python Projects(http://pythonpracticeprojects.com/)

The Official Docs (http://docs.python.org/2/)

Hitchhiker’s Guide to Python (http://docs.python-guide.org/en/latest/)

Python Module of the Week (http://pymotw.com/2/)

Python Course(http://www.python-course.eu/index.php)

First Steps With Python(https://realpython.com/learn/python-first-steps/)

A Crash Course in Python for Scientists (http://nbviewer.ipython.org/5920182)

First Steps With Python (https://realpython.com/learn/python-first-steps/)

Fullstack Python (https://www.fullstackpython.com/)

30Python Language Features and Tricks You May Not Know About(http://sahandsaba.com/thirty-python-language-features-and-tricks-you-may-not-know.html)

Official Style Guide for Python(https://www.python.org/dev/peps/pep-0008/)

Python 3 Computer Science Circles(http://cscircles.cemc.uwaterloo.ca/)

上一篇:

下一篇: