分刻みで一つの言語を習得するPython編
51761 ワード
Python was created by Guido Van Rossum in the early 90's. It is now one of the most popularlanguages in existence. I fell in love with Python for its syntactic clarity. It's basicallyexecutable pseudocode.
Pythonは90年代初めにGuido Van Rossumによって創設された.現在最も流行しているプログラム言語の一つです.その純粋な文法に一目惚れしました.それはまるで実行可能な偽コードです.
Feedback would be highly appreciated! You can reach me at @louiedinh or louiedinh [at] [google's email service]
フィードバックの提出を歓迎します.@louiedinhで私に連絡してもいいし、
Note: This article applies to Python 2.7 specifically, but should be applicableto Python 2.x. Look for another tour of Python 3 soon!
注意:本文はPython 2.7を基準とするが、すべての2.Xバージョン.未来のPython 3を勉強し続けてね!
Ready For More?
まだ中毒になっていませんか.
Free Online
無料オンライン読書 Learn Python The Hard Way Dive Into Python The Official Docs Hitchhiker's Guide to Python Python Module of the Week
Dead Tree
実体書 Programming Python Dive Into Python Python Essential Reference
転入先https://github.com/cssmagic/blog/issues/24
突っ込む.どんなプログラムでも分を分けてマスターできるようになったら、プログラム猿が毛を乾かす必要があります.の言うなら彼の分间で実现できる私cも実现できるのになぜPYTHONを使わなければならないのですか?
Pythonは90年代初めにGuido Van Rossumによって創設された.現在最も流行しているプログラム言語の一つです.その純粋な文法に一目惚れしました.それはまるで実行可能な偽コードです.
Feedback would be highly appreciated! You can reach me at @louiedinh or louiedinh [at] [google's email service]
フィードバックの提出を歓迎します.@louiedinhで私に連絡してもいいし、
louiedinhで始まるGoogle Emailアカウントにメールしてもいいです.Note: This article applies to Python 2.7 specifically, but should be applicableto Python 2.x. Look for another tour of Python 3 soon!
注意:本文はPython 2.7を基準とするが、すべての2.Xバージョン.未来のPython 3を勉強し続けてね!
# Single line comments start with a hash.
# 。
""" Multiline strings can be written
using three "'s, and are often used
as comments
（ ） ，
。
"""
####################################################
## 1. Primitive Datatypes and Operators
## 1.
####################################################
# You have numbers
#
3 #=> 3
# Math is what you would expect
#
1 + 1 #=> 2
8 - 1 #=> 7
10 * 2 #=> 20
35 / 5 #=> 7
# Division is a bit tricky. It is integer division and floors the results
# automatically.
# 。
# ， 。
5 / 2 #=> 2
# To fix division we need to learn about floats.
# ， 。
2.0 # This is a float
2.0 #
11.0 / 4.0 #=> 2.75 ahhh...much better
11.0 / 4.0 #=> 2.75 ……
# Enforce precedence with parentheses
#
(1 + 3) * 2 #=> 8
# Boolean values are primitives
#
True
False
# negate with not
# not
not True #=> False
not False #=> True
# Equality is ==
# ==
1 == 1 #=> True
2 == 1 #=> False
# Inequality is !=
# !=
1 != 1 #=> False
2 != 1 #=> True
# More comparisons
#
1 < 10 #=> True
1 > 10 #=> False
2 <= 2 #=> True
2 >= 2 #=> True
# Comparisons can be chained!
# ！
1 < 2 < 3 #=> True
2 < 3 < 2 #=> False
# Strings are created with " or '
# " '
"This is a string."
'This is also a string.'
# Strings can be added too!
# ！
"Hello " + "world!" #=> "Hello world!"
# A string can be treated like a list of characters
#
# （ ： “ ”。）
"This is a string"[0] #=> 'T'
# % can be used to format strings, like this:
# % ， ：
"%s can be %s" % ("strings", "interpolated")
# A newer way to format strings is the format method.
# This method is the preferred way
# ：format 。
# 。
"{0} can be {1}".format("strings", "formatted")
# You can use keywords if you don't want to count.
# ， （ ）。
"{name} wants to eat {food}".format(name="Bob", food="lasagna")
# None is an object
# None
None #=> None
# Don't use the equality `==` symbol to compare objects to None
# Use `is` instead
# `==` None ，
# `is`。
"etc" is None #=> False
None is None #=> True
# The 'is' operator tests for object identity. This isn't
# very useful when dealing with primitive values, but is
# very useful when dealing with objects.
# `is` 。
# （ ： ， ， 。）
# ，
# 。
# None, 0, and empty strings/lists all evaluate to False.
# All other values are True
# None、0 False，
# True。
0 == False #=> True
"" == False #=> True
####################################################
## 2. Variables and Collections
## 2.
####################################################
# Printing is pretty easy
#
print "I'm Python. Nice to meet you!"
# No need to declare variables before assigning to them.
#
some_var = 5 # Convention is to use lower_case_with_underscores
#
some_var #=> 5
# Accessing a previously unassigned variable is an exception.
# See Control Flow to learn more about exception handling.
# 。
# ， 《 》。
some_other_var # Raises a name error
#
# if can be used as an expression
# if
"yahoo!" if 3 > 2 else 2 #=> "yahoo!"
# Lists store sequences
#
li = []
# You can start with a prefilled list
#
other_li = [4, 5, 6]
# Add stuff to the end of a list with append
# append
li.append(1) #li is now [1]
#li [1]
li.append(2) #li is now [1, 2]
#li [1, 2]
li.append(4) #li is now [1, 2, 4]
#li [1, 2, 4]
li.append(3) #li is now [1, 2, 4, 3]
#li [1, 2, 4, 3]
# Remove from the end with pop
# pop
li.pop() #=> 3 and li is now [1, 2, 4]
#=> 3， li [1, 2, 4]
# Let's put it back
#
li.append(3) # li is now [1, 2, 4, 3] again.
# li [1, 2, 4, 3]
# Access a list like you would any array
#
li[0] #=> 1
# Look at the last element
#
li[-1] #=> 3
# Looking out of bounds is an IndexError
#
li[4] # Raises an IndexError
#
# You can look at ranges with slice syntax.
# (It's a closed/open range for you mathy types.)
# 。
# （ 。）
li[1:3] #=> [2, 4]
# Omit the beginning
#
li[2:] #=> [4, 3]
# Omit the end
#
li[:3] #=> [1, 2, 4]
# Remove arbitrary elements from a list with del
# del
del li[2] # li is now [1, 2, 3]
# li [1, 2, 3]
# You can add lists
#
li + other_li #=> [1, 2, 3, 4, 5, 6] - Note: li and other_li is left alone
#=> [1, 2, 3, 4, 5, 6] - li other_li
# Concatenate lists with extend
# extend
li.extend(other_li) # Now li is [1, 2, 3, 4, 5, 6]
# li [1, 2, 3, 4, 5, 6]
# Check for existence in a list with in
# in
1 in li #=> True
# Examine the length with len
# len
len(li) #=> 6
# Tuples are like lists but are immutable.
# ， “ ” 。
tup = (1, 2, 3)
tup[0] #=> 1
tup[0] = 3 # Raises a TypeError
#
# You can do all those list thingies on tuples too
#
len(tup) #=> 3
tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
tup[:2] #=> (1, 2)
2 in tup #=> True
# You can unpack tuples (or lists) into variables
# （ ）
a, b, c = (1, 2, 3) # a is now 1, b is now 2 and c is now 3
# a 1，b 2，c 3
# Tuples are created by default if you leave out the parentheses
# ，
d, e, f = 4, 5, 6
# Now look how easy it is to swap two values
# 。
e, d = d, e # d is now 5 and e is now 4
# d 5 e 4
# Dictionaries store mappings
#
empty_dict = {}
# Here is a prefilled dictionary
#
filled_dict = {"one": 1, "two": 2, "three": 3}
# Look up values with []
# []
filled_dict["one"] #=> 1
# Get all keys as a list
#
filled_dict.keys() #=> ["three", "two", "one"]
# Note - Dictionary key ordering is not guaranteed.
# Your results might not match this exactly.
# ： 。
# 。
# Get all values as a list
#
filled_dict.values() #=> [3, 2, 1]
# Note - Same as above regarding key ordering.
# ： 。
# Check for existence of keys in a dictionary with in
# in
"one" in filled_dict #=> True
1 in filled_dict #=> False
# Looking up a non-existing key is a KeyError
#
filled_dict["four"] # KeyError
#
# Use get method to avoid the KeyError
# get
filled_dict.get("one") #=> 1
filled_dict.get("four") #=> None
# The get method supports a default argument when the value is missing
# get ， 。
filled_dict.get("one", 4) #=> 1
filled_dict.get("four", 4) #=> 4
# Setdefault method is a safe way to add new key-value pair into dictionary
# Setdefault
filled_dict.setdefault("five", 5) #filled_dict["five"] is set to 5
#filled_dict["five"] 5
filled_dict.setdefault("five", 6) #filled_dict["five"] is still 5
#filled_dict["five"] 5
# Sets store ... well sets
# set
empty_set = set()
# Initialize a set with a bunch of values
#
some_set = set([1,2,2,3,4]) # some_set is now set([1, 2, 3, 4])
# some_set set([1, 2, 3, 4])
# Since Python 2.7, {} can be used to declare a set
# Python 2.7 ，{}
filled_set = {1, 2, 2, 3, 4} # => {1, 2, 3, 4}
# （ ： ， 2 。）
# （ ：{} ， 。）
# Add more items to a set
#
filled_set.add(5) # filled_set is now {1, 2, 3, 4, 5}
# filled_set {1, 2, 3, 4, 5}
# Do set intersection with &
# &
other_set = {3, 4, 5, 6}
filled_set & other_set #=> {3, 4, 5}
# Do set union with |
# |
filled_set | other_set #=> {1, 2, 3, 4, 5, 6}
# Do set difference with -
# -
{1,2,3,4} - {2,3,5} #=> {1, 4}
# Check for existence in a set with in
# in
2 in filled_set #=> True
10 in filled_set #=> False
####################################################
## 3. Control Flow
## 3.
####################################################
# Let's just make a variable
#
some_var = 5
# Here is an if statement. Indentation is significant in python!
# prints "some_var is smaller than 10"
# 。 Python ！
# "some_var is smaller than 10"
# （ ： “some_var 10 ”。）
if some_var > 10:
print "some_var is totally bigger than 10."
# （ ： “some_var 10 ”。）
elif some_var < 10: # This elif clause is optional.
# elif
print "some_var is smaller than 10."
# （ ： “some_var 10 ”。）
else: # This is optional too.
#
print "some_var is indeed 10."
# （ ： “some_var 10”。）
"""
For loops iterate over lists
for
prints:
：
dog is a mammal
cat is a mammal
mouse is a mammal
"""
for animal in ["dog", "cat", "mouse"]:
# You can use % to interpolate formatted strings
# %
print "%s is a mammal" % animal
# （ ： “%s ”。）
"""
`range(number)` returns a list of numbers
from zero to the given number
`range( )` ，
。
prints:
：
0
1
2
3
"""
for i in range(4):
print i
"""
While loops go until a condition is no longer met.
while ， 。
prints:
：
0
1
2
3
"""
x = 0
while x < 4:
print x
x += 1 # Shorthand for x = x + 1
# x = x + 1
# Handle exceptions with a try/except block
# try/except
# Works on Python 2.6 and up:
# Python 2.6 ：
try:
# Use raise to raise an error
# raise
raise IndexError("This is an index error")
# ：“ ”。
except IndexError as e:
pass # Pass is just a no-op. Usually you would do recovery here.
# pass 。 。
####################################################
## 4. Functions
## 4.
####################################################
# Use def to create new functions
# def
def add(x, y):
print "x is %s and y is %s" % (x, y)
# （ ： “x %s y %s”。）
return x + y # Return values with a return statement
# return
# Calling functions with parameters
#
add(5, 6) #=> prints out "x is 5 and y is 6" and returns 11
# （ ： “x 5 y 6”， 11）
# Another way to call functions is with keyword arguments
#
add(y=6, x=5) # Keyword arguments can arrive in any order.
#
# You can define functions that take a variable number of
# positional arguments
# ， 。
def varargs(*args):
return args
varargs(1, 2, 3) #=> (1,2,3)
# You can define functions that take a variable number of
# keyword arguments, as well
# ， 。
def keyword_args(**kwargs):
return kwargs
# Let's call it to see what happens
# ， ：
keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"}
# You can do both at once, if you like
# ， ：
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 varargs/kwargs!
# Use * to expand tuples and use ** to expand kwargs.
# ， 。
# * ， ** 。
args = (1, 2, 3, 4)
kwargs = {"a": 3, "b": 4}
all_the_args(*args) # equivalent to foo(1, 2, 3, 4)
# all_the_args(1, 2, 3, 4)
all_the_args(**kwargs) # equivalent to foo(a=3, b=4)
# all_the_args(a=3, b=4)
all_the_args(*args, **kwargs) # equivalent to foo(1, 2, 3, 4, a=3, b=4)
# all_the_args(1, 2, 3, 4, a=3, b=4)
# Python has first class functions
# Python
def create_adder(x):
def adder(y):
return x + y
return adder
add_10 = create_adder(10)
add_10(3) #=> 13
# There are also anonymous functions
#
(lambda x: x > 2)(3) #=> True
# There are built-in higher order functions
#
map(add_10, [1,2,3]) #=> [11, 12, 13]
filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
# We can use list comprehensions for nice maps and filters
# map filter
[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]
####################################################
## 5. Classes
## 5.
####################################################
# We subclass from object to get a class.
# ， 。
class Human(object):
# A class attribute. It is shared by all instances of this class
# 。 。
species = "H. sapiens"
# Basic initializer
# （ ）
def __init__(self, name):
# Assign the argument to the instance's name attribute
# name
self.name = name
# An instance method. All methods take self as the first argument
# 。 self 。
def say(self, msg):
return "%s: %s" % (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*"
# Instantiate a class
#
i = Human(name="Ian")
print i.say("hi") # prints out "Ian: hi"
# "Ian: hi"
j = Human("Joel")
print j.say("hello") # prints out "Joel: hello"
# "Joel: hello"
# Call our class method
#
i.get_species() #=> "H. sapiens"
# Change the shared attribute
#
Human.species = "H. neanderthalensis"
i.get_species() #=> "H. neanderthalensis"
j.get_species() #=> "H. neanderthalensis"
# Call the static method
#
Human.grunt() #=> "*grunt*"
####################################################
## 6. Modules
## 6.
####################################################
# You can import modules
#
import math
print math.sqrt(16) #=> 4
# You can get specific functions from a module
#
from math import ceil, floor
print ceil(3.7) #=> 4.0
print floor(3.7) #=> 3.0
# You can import all functions from a module.
# Warning: this is not recommended
#
# ：
from math import *
# You can shorten module names
#
import math as m
math.sqrt(16) == m.sqrt(16) #=> 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.
# Python Python 。
# ， 。
# 。
# You can find out which functions and attributes
# defines a module.
#
import math
dir(math)
Ready For More?
まだ中毒になっていませんか.
Free Online
無料オンライン読書
Dead Tree
実体書
転入先https://github.com/cssmagic/blog/issues/24
突っ込む.どんなプログラムでも分を分けてマスターできるようになったら、プログラム猿が毛を乾かす必要があります.の言うなら彼の分间で実现できる私cも実现できるのになぜPYTHONを使わなければならないのですか?