Python

简介

Python 由 Guido van Rossum(荷兰 ??)开发。

Python 是一门解释型语言、动态类型(弱类型)语言。

Python 的名字来源于 Monty Python’s Flying Circus。

保存词

不能使用保存词(reserved words)来命名变量名称,这样的词有:

False, class, return, is, finally, None, if, for, lambda, continue, True, def, from, while, nonlocal, and, del, global, not, with, as, elif, try, or, yield, assert, else, import, pass, break, in, raise

Python 的关键字很接近自然语言:

  • True,False 布尔值,相当于“真,假”,类似于其他语言中的 true, false

  • None 相当与“空”,类似于其它语言中的 null

  • is,is not 运算符用于逻辑表达式,前者的意思是“和什么相同”,相似于 ==,但是更强。is 同时检查值和类型,常用在 None 或者布尔值的判断,类似 JavaScript 中的 ===

0 == 0.0 # True
0 is 0.0 # False

 

构建块

赋值

赋值就是把变量名和数值联系起来,定义函数就是把函数名和表达式联系起来。

赋值运算符 =

常量

Python 中可以直接使用常量。

print(322)
print(5.3)
print("Hello World")

变量

Python 中的变量不需要用关键字声明,可以直接赋值。

x = 12.2    
y = 14      

变量命名规则

  • 必须以字母或下划线 _ 开头

  • 必须由字母、数字和下划线组成

  • Python 区分大小写

语句

x = 2 # 赋值语句
x = x + 2 # 赋值表达式
print(x) # print 语句

使用 = 把值赋值给某一个变量。赋值运算符是从右开始计算的。

 

环境图

环境图用于显示变量和其数值之间的对应关系。

 

表达式

表达式描述了一次计算和取值。

所有的表达式都可以通过函数表达式实现。

例如:max(1,2) 这样的称为调用表达式(call expression),它的结构如下:

add        (2    ,     3)
operator operand operand

操作符和操作数也是表达式。

数字表达式

使用 +, -, *, /, **, % 做数学运算,其中 ** 是幂运算。

print(4 ** 3) # 64

运算符的优先级

  • 括号最高 ()

  • 幂运算 **

  • 乘法、除法、求余 * / %

  • 加法、减法 + -

  • 从左到右 from left to right

逻辑运算符

  • not 为非运算符,类似其他语言的 !

  • and 为与运算符,类似其他语言的 &&

  • or 为或运算符,类似其它语言的 ||

三元运算符

Python 中的三元运算符和其他编程语言不同: condition ? x : y,而是 result = x if condition else y

 

类型

Python 的变量、常量、字面量都有类型。

有些运算是禁止的,例如:1 + string。

可以使用 type() 找出某个数据的类型。

Python 中有隐式类型转换。

type(1)
# <class'int'>

数字

主要有 int, float, double 类型。

Python 中整数的除法结果是浮点数。

字符串转化

可以使用 int(),float(),可以把字符串变成整数。如果字符串中不包含数字,那么会得到 error

 

字符串

Python 可以使用单引号 '' 或者双引号 "" 来表示字符串。

字符串包含数字,仍然是字符串。

字符串是不可变的(immutable)。例如:

s = "hello"
s[0] = 'y' # error
s = 'y' + s[1:len(s)] # 可以,因为 s 现在是一个新对象
s = "yello" # 可以

字符数字转换

可以使用 int() 把字符串转化为数字。

可以使用 str() 把数字转化为字符串。

通常使用字符串来接收输入,然后再转化为想要的类型。

Python 3 中所有的字符串编码都是 Unicode。

字符串索引

可以使用 [] 来获取字符串中某个位置的字符。索引从 0 开始。

在 Python 中可以使用负值作为索引,最后一个元素的索引为 -1,随着负值的减小,也就是绝对值的增大,实际上相当于从右往左访问字符串。

fruit = 'app'
letter = fruit[0]
print(letter) # a
print(fruit[9]) # error
print(fruit[-1]) # p

字符串长度

使用 len() 获得字符串的长度。

fruit = 'banana'
x = len(fruit)
print(x) # 6

字符串循环

下面两段代码是一样的效果,第二种更 Python。

s = "abcdef"
for index in range(len(s)):
 if s[index] == 'i' or s[index] == 'u':
   print("there is i or u")
   
   
for char in s:
 if char == 'i' or char == 'u':
   print("there is i or u")

可以使用 for 或 while 循环。

fruit = 'banana'
index = 0
while index < len(fruit):
 letter = fruit(index)
 print(letter)
 index = index + 1
 
 
for letter in fruit:
 print(letter)

字符串切片

使用 : 运算符(colon operator)完成字符串的切片操作。

切片运算符 [start:stop:step]

第一个数字是切片的开始位置,第二个数字是指切片的结束位置(直到但不包含该位置),第三个数字代表步长(默认为 1)。

如果省略第一或第二个数字,只留下冒号,那么默认从头或到尾。

s = 'Monty Python'
print(s[0:4]) # Mont
print(s[8:]) # thon
print(s[:2]) # Mo
print(s[:]) # Monty Python

s = "abcdefgh"
s[3:6] # "def" 和 s[3:6:1] 相同
s[3:6:2] # "df"
s[::] # "abcdefgh" 和 s[0:len(s):1] 相同
s[::-1] # "hgfedbca" 和 s[-1:-(len(s)+1):-1] 相同,相当于反转字符串
s[4:1:-1] # "ec"

字符串拼接

使用 + 连接(concatenate)字符串。

hello = "hello"
world = "world"
print(hello + world)
# helloworld

检测子串

使用 in 作为逻辑运算符。可以检测一个字符串是否被包含在另一个字符串中,返回一个布尔值。

fruit = 'banana'
'n' in fruit # True
'm' in fruit # False

字符串比较

使用比较运算符比较字符串。

if word == 'banana':
 print("all right")

if word < 'banana':
 print('your word' + word + ', coes before banana')

字符串重复

使用 * 运算符来对字符串重复。

silly = "hello" * 3
print(silly)
# hellohellohello

字符串库

使用字符串库中的函数,这些函数不会改变原本的字符串,而是返回一个新字符串。

使用 type() 查看字符串类型,类似 JavaScript 的 typeofdir() 可以查看能够用在字符串上的所有方法。

s = ""
type(s)
>>> <type 'str'>

使用 find() 查找字符串的子串,它查找子串第一次出现的位置,如果没有找到返回 -1,类似 JavaScript 的 indexOf()

fruit = 'banana'
pos = fruit.find('na')
print(pos) # 2

使用 lower(), upper() 把字符串转化为小写或者大写,类似 JavaScript 的 toUpperCase(), toLowerCase()

great = 'Hello World'
zap = great.lower()
print(zap) # hello world

使用 replace() 意思是查找并替换,它会替换所有查找到的子串。

great = 'hello bob'
nstr = great.replace('bob', 'jane')
print(nstr) # hello jane
nstr = great.replace('o', 'x')
print(nstr) # hellx bxb

使用 lstrip()rstrip() 来移除左边或者右边的空白,strip() 移除所有空白。

greet = '   hello bob   '
greet.lstrip() # 'hello bob   '
greet.rstrip() # '   hello bob'
greet.strip() # 'hello bob'

使用 startswith() 来判断字符串前缀。

line = 'please have a nice day'
line.startswith('please') # True

split() 方法把一个字符串分割成一个字符串列表。

如果没有指定分割符,默认采用空格作为分隔符。

abc = 'with three words'
stuff = abc.split()
print(stuff)
['with', 'three', 'words']
print(len(stuff))
# 3
line = 'first:second:third'
thing = line.split()
print(thing)
# ['first:second:third']
print(len(thing))
# 1
thing = line.split(":")
print(thing)
# ['first','second','third']

两次切片

words = 'His e-mail is q-lar@freecodecamp.org'
pieces = words.split()
parts = pieces[3].split('-')
n = parts[1]
# lar@freecodecamp.org

 

输入输出

输入

使用 input() 获得用户输入,该函数返回一个字符串。

name = input('Who are you')
print('welcome', name)

输入的转化

如果想读一个数字,那么必须把获取的字符串转化为数字。

inp = input('Europe floor')
usf = int(inp)
# usf = float(inp)
print('US floor', usf)

输出

使用 print() 输出。使用 , 可以在值中间添加空格。如果使用 + 需要保证两端都是字符串。

x = 1
print(x)
x_str = str(x)
print(x)
print("my fav num is", x, ".", "x = ", x)
print("my fav num is" + x_str + ". " + "x = " + x_str)

注释

Python 使用 # 来注释单行语句。

使用 '''''' 注释多行语句。

# 注释

'''
注释
'''

Python 脚本

Python 的文件以 .py 结尾。

运行 Python 文件使用命令:

python file.py

 

缩进

  • 缩进(indentation)出现在 if 语句或者 for 语句等之后的 :

  • 使用缩进来指示作用域

  • iffor 语句结束时要把缩进返回到上一级

  • 空行会被忽略,它们不会影响缩进

  • 注释同样会被忽略

注:Python 检查缩进的正确性,所以不要弄混 spacetab

 

条件

x = 5
if x < 10:
 print("smaller")
if x > 20:
 print("bigger")
print("Finis")

比较运算符

比较运算符:<, <=, ==, >=, >, !=

比较运算符常用在布尔表达式中,返回真或假。

比较运算符不会改变变量的值。

if else

x = 4
if x > 2:
 print("bigger")
else:
 print("smaller")
print 'all done'

if elif else

if x < 2:
 print("small")
elif x < 10:
 print("meduim")
else:
 print("large")
print("all done")

为“True”的条件

a = True

if a is True:
 print("True")
 
if a == True:
 print("True")
 
if a:
 print("True")
 
if bool(a):
 print("True")
 
# 以上四种结果皆为 True  

以上四种判断的相同点:

  • 结果均为 True

不同点:

  • 第一种是判断 a 是否为 True,如果是 True 之外的任何一个值,都不会通过条件判断。

    这种做法适合于把 True 单独拿出来作为一种情况。

    a is True 的反面不是 a is False,而是 a is not True。

  • 第二种实际上不太应该出现。

    == 运算符在 Python 中会被重载,所以判断是不是 True 本人,应该用第一种做法。

  • 第三种适合于非常确定 a 的类型的情况。

  • 第四种中 bool 是一个 Class,这种写法和第三种没有什么区别。

循环

while

n = 5
while n > 0:
 print(n)
 n = n - 1
print("blasoff")

使用 break 语句可以结束并跳出当前循环。

while True:
 line = input('>')
 if line == 'done':
   break
 print(line)
print('done')

使用 break 语句可以结束当前循环并回到循环顶部。

while True:
 line = input('> ')
 if line[0] == '#':
   continue
 if line == 'done':
   break
 print(line)
print('done!')  

 

for

for range

有些循环的次数是确定的:

for n in range(5):
 print(n)
 # 0 1 2 3 4

注意从 0 开始,然后到 range 内的值减 1。

range 函数签名:range(start, stop, step),其中 start 代表迭代开始的数字,stop 代表结束的数字 + 1,step 代表迭代的步长。参数必须是整数。如果是倒序循环,步长为 -1

for i in range(1,4):
 print(i)
# 1,2,3

for i in range(1,4,2):
 print(i)
# 1,3

 

for in

例如 for in 循环可以迭代集合全部元素,类似 JavaScript 的 forEach()

for i in [1,2,3,4,5]:
 print(i)
print('blase off')
# 1,2,3,4,5

friends = ['tom','cat']
for friend in friends:
 print('happy:', friend)
print('done')
# happy: tom
# happy: cat
# done

上面例子中的:ifriend 被称为迭代变量,用来迭代列表。每次只会执行一次。

 

更“聪明”的循环:

找出列表中的最大数字:

largest_so_far = -1
print("before", largest_so_far)
for the_num in [1,2,3,45,6]:
 if the_num > largest_so_far:
   largest_so_far = the_num
 print(largest_so_far, the_num)
 
print('after', largest_so_far) # 74

计数循环:

zork = 0
print('before', zork)
for thing in [1,2,3,4,5]:
 zork = zork + 1
 print(zork, thing)
print('after', zork)

计算总和:

zork = 0
print('before', zork)
for thing in [1,2,3,4,5]:
 zork = zork + thing
 print(zork, thing)
print('after', zork)

平均数:

count = 0
sum = 0
for value in [1,2,3,4,5]:
 count = count + 1
 sum = sum + value
print('average', sum / count)

使用布尔值查找变量:

found = False
for value in [1,2,3,4,5]:
 if value == 3:
   found = True
print(found)

函数

定义

函数是保存并重复使用的代码段,它接收参数, 做运算,并返回结果。

直到程序调用(called)或者引用(invoked)函数才会运行。

特点

  • 有函数名

  • 有参数(0 或多个)

  • 有注释(docstring)(可选但是推荐)

  • 有函数体

  • 有返回值

编写和调用

使用 def 关键字去定义函数。

通过函数名来调用函数。

Python 中有两种函数:

  1. 内置函数是 Python 语言提供的

  2. 自定义的函数

return 语句会结束函数执行,并返回函数的结果。

如果没有指定 return 语句, Python 会返回 None

实参(actual parameter),形参(formal parameter),参数可以是函数类型的。

函数签名指明了函数接受参数的个数,函数签名含有所有创造局部作用域的信息。

def <name>(<formal parameters>):
 return <return expression>
def fun_a():
 print("this is a")

print fun_a() # None

下面是一个例子:

def is_even(i):
 """
Input: i, a positive int
Returns True if i is even, otherwise False
"""
 print("inside is_even")
 return i % 2 == 0

is_even(3)
def thing():
 print('hello')
 print('fun')
thing()
print('zip')
thing()

def great(lang):
 if lang == 'es':
   print('hola')
 elif lang == 'fr':
   print('bonjour')
 else:
   print('hello')

作用域

有全局作用域和局部作用域两种。

  • 在函数内部,可以访问外部定义的变量

  • 在函数内部,不能改变外部定义的变量 — 可以使用全局变量

# example1
def f(y):
 x = 1
 x += 1
 print(x)
 
x = 5
f(x)
print(x)

# example2
def g(y):
 print(x)
 print(x + 1)

x = 5
g(5)
print(x)

# example3
def h(y):
 x += 1
 
x = 5
h(x)
print(x)
# unboundLocalError

 

列表

定义

列表是一种集合。有许多值存在一个变量中。

friends = ['wu', 'niu', 'su']

列表常量是指用户用方括号 [] 包围的一组元素,元素之间用逗号分割。

列表的元素可以是任何 Python 对象,甚至是另一个列表(广义表)。

列表可以为空。

l = []
c = ['code', 42]
a = [3, [2,1], 3]

访问

可以使用方括号实现索引访问列表。

code = ['code','apple']
print(code[0]) # code

列表是可变的(mutable),可以使用索引操作符修改列表元素,仍然是一个对象。字符串是不可变的,必须在一个新的字符串上做修改。

c = ['code', 42]
c[0] = 1
print(c) # [1, 42]

迭代

列表可以被迭代,下面是两种常用的模式。

注:

  • 索引从 0len(l) - 1

  • range(n) 从 0n-1

# example1
total = 0
for i in range(len(l)):
 total += l[i]
print total

# example2
total = 0
for i in l:
 total += i
print total

拼接

使用 + 拼接列表,原来的列表不会被改变。

a = [1,2,3]
b = [4,5,6]
c = a + b
print(c) #[1,2,3,4,5,6]

切片

使用 : 对列表做切片。

t = [1,2,3,4,5]
t[1:4] #2,3,4

type() & dir()

使用 type() 查看列表类型,dir() 可以查看能够用在列表上的所有方法。

<type 'list'>

添加

使用 append() 方法添加元素到列表末尾。

stuff = list()
stuff.append('book')
stuff.append('cookie')

删除

使用 del(L[index]) 可以删除一个给定索引的元素。

使用 pop() 删除列表的末尾元素,并返回被删除的元素。

使用 L.remove(element) 删除一个给定元素。

  • 先找到元素并删除

  • 如果该元素出现了多次,只删除第一个

  • 如果列表没有该元素,给出错误

L = [2,1,3]
L.remove(2) # L = [1,3]
del(L[0]) # L = [3]
L.pop() # return 3 && L = []

in & not in

使用 in, not in 判断某元素是否在一个列表,返回一个布尔值。

t = [1,2,3,4,5]
1 in t
# True
8 not in t
# True

排序、反转

使用 sort()sorted() 对列表排序。

sorted() 不会改变原列表,返回一个排序列表。

sort() 排序原列表。

reverse() 反转列表。

t = [1,3,2,4,5]
t.sort() # t = [1,2,3,4,5]
t.sorted() # return [1,2,3,4,5] t = [1,3,2,4,5]
t.reverse() # t = [5,4,2,3,1]

len(),max(),min(),sum()

len(),max(),min(),sum()等方法把列表作为参数。

列表字符串互转

使用 list(s) 把字符串转化为列表,返回一个列表带有字符串中的每个字符。

使用 s.split() 分割一个字符串根据指定参数,如果没有参数则以空格分割。

使用 ``.join(L) 把字符列表转化字符串。引号里的内容是每个元素间的分隔符。

s = "I<3 cs"
list(s) # ['I', '<', '3', ' ', 'c', 's']
s.split('<') # ['I', '3 cs']

L = ['a','b','c']
''.join(L) # "abc"
'_'.join(L) #a_b_c

克隆

使用 [:] 克隆一个列表(创建一个新列表,并拷贝所有元素)

cool = ['blue']
chill = cool[:]
chill.append('black')
print(chill) # ['blue','black']
print(cool) # ['blue']

 

字典

定义

字典(dictionary)是多个值的“背包”,每个值都有一个标签,类似于键值对,哈希表数据结构,JavaScript 对象,Java 属性或者 Map 或 HashMap。

字典字面量(常量)使用花括号 {} 来表示一个键值对组。也可以使用花括号来创建空字典。

字典的值可以是任何类型,但是键必须是唯一的,而且必须是不可变的,也就是 float、tuple、int、string、boolean。

jjj = {'chuck': 1, 'fred': 43, 'jan': 100}
print(jjj)
# {'chuck': 1, 'fred': 43, 'jan': 100}
ooo = {}
print(ooo)
# {}

访问

字典是无序的,所以不能用位置也就是数字索引访问,需要标签,也就是字符索引。

purse = dict()
purse['money'] = 12
purse['candy'] = 12
print(purse)
# ['money': 12, 'candy': 12]
purse['candy'] = purse['candy'] + 2
print(purse)
# ['money': 12, 'candy': 14]

如果访问一个不存在的键,Python 会给 error。

添加删除

使用 [] = 来添加一个键值对。

grades['Sylvan'] = 'A'

使用 del() 删除一个键值对。

del(grades['Ana'])

in

可以使用 in 操作符访问键是否在字典中。

ccc = dict()
print(ccc['csev'])
# Traceback ...
'csev' in ccc
# False

如果发现了一个新名字,加入字典,随后再发现,就叠加字典的值

counts = dict()
names = ['csev','cwen']
for name in names:
 if name not in counts:
   counts[name] = 1
 else:
   counts[name] = counts[name] + 1
print(counts)    

get

get() 方法检查字典中是否已经存在一个键,如果不存在会给该键设定一个默认值。

if name in counts:
 x = counts[name]
else:
 x = 0

# 上面 4 行和下面 1 行相同

x = counts.get(name, 0)  

计算文本中每行的字数需要分割行为单词,然后循环单词列表,并用字典去跟踪每个单词。

counts = dict()
print('enter a line of text: ')
line = input('')

words = line.split()

print("words: "+ words)

print("counting...")
for word in words:
 counts[word] = counts.get(word,0) + 1
print('counts', counts)

尽管字典是无序的,但是仍然可以使用 for 循环去迭代字典的键。

counts = {'chuck': 1, 'fred': 43, 'jan': 100}
for key in counts:
 print(key, counts[key])
 
# chuck 1
# fred 43
# jan 100

list()、.keys()、.items()

使用 list() 把字典的键转化为列表。

使用 .keys() 得到字典的键的列表, 使用 values() 得到字典值的列表,使用 .items() 得到字典键值对的元组。

jjj = {'chuck': 1, 'fred': 43, 'jan': 100}
print(list(jjj))
# ['chunk','fred','jan']
print(jjj.keys())
# ['chunk','fred','jan']
print(jjj.values())
# [1,43,100]
print(jjj.items())
# [('chuck', 1), ('fred', 43), ('jan', 100)]

双迭代变量,可以直接输出键值对。

jjj = {'chuck': 1, 'fred': 43, 'jan': 100}
for aaa,bbb in jjj.items():
 print(aaa, bbb)

# chuck 1
# fred 43
# jan 100

双重循环

bigcount = None
bigword = None
for word.count in counts.items():
 if bigcount is None or count > bigcount:
   bigword = word
   bigcount = count
print(bigword, bigcount)  

 

元组

定义

元组(tuple)类似于列表,索引也是从 0 开始。

元组可以包含整型、浮点型、字符串等。

使用括号(parentheses) () 来表示元组。

te = ()

t = (2, "mit", 3)

x = ('Glenn', 'Sally')
print(x[1])
# Sally

y = (1, 2, 3)
print(y[1])
# 2
print(max(y))
# 3

for item in y:
 print(item)
# 1
# 2
# 3

元组和列表的区别是,元组是不能改变的(immutable),这类似于字符串。

元组中不能做的事

  • 元组对象不能被排序(sort())

  • 元组对象不能添加(append())

  • 元组对象不能被翻转(reverse())

元组只有 countindex 属性。

拼接元组

使用 + 可以拼接元组

(2, "mit", 3) + (5, 6)
# (2, "mit", 3, 5, 6)

元组切片

使用 [:] 可以对元组切片。

t[1:2] # ("mit", )
t[1:3] # ("mit", 3)

注意第一个例子的 , 不是错误,而是 Python 表示这是一个元组,否则就变成了字符串。

元组大小

使用 len() 得到元组大小。

便捷的交换操作

(x, y) = (y, x)

赋值

可以把元组放在赋值运算符的左侧,甚至可以忽略括号。

(x, y) = (4, 'fred')
print(y) # fred
(a, b) = (99, 98)
print(a) # 99

比较

元组是可以比较的。如果第一个元素相同,会继续比较。

(0, 1, 2) < (5, 1, 2)
# True
(0, 1, 20000) < (0, 3, 4)
# True

迭代

元组可以被迭代。

排序

可以使用 sorted() 对元组列表排序。

d = ['a': 10, 'b': 10, 'c': 10]
d.items()
sorted(d.items())

按值排序:

d = ['a': 10, 'b': 20, 'c': 30]
tmp = list()
for k,v in c.items():
 tmp.append((v, k))
print(tmp)
# [(10, 'a'), (30, 'c'), (20, 'b')]
tmp = sorted(tem, reverse=True)
print(tmp)
# # [(30, 'c'), (20, 'b'), (10, 'a')]

更短的版本:

print(sorted([(v, k) for k,v in c.items() ]))

 

别名

所有的别名(alias)指向同一对象,所以对其中一个更改,其他的也会更改。

a = 1
b = a
print(a) # 1
print(b) # 1

warm = ['red', 'yellow', 'orange']
hot = warm
hot.append('pink')
print(hot) # ['red', 'yellow', 'orange', 'pink']
print(warm) # ['red', 'yellow', 'orange', 'pink']

断言

断言(assertion)用来判断预期和实际结果相同。

def avg(grades):
 assert not len(grades) == 0, 'no grades data'
 return sum(grades)/len(grades)

如果是空列表,给出 AssertionError,其他情况 ok。

 

异常

try except

异常使用 try/except 结构。

  • 对于一段“危险”代码,应该使用异常处理

  • 如果 try 中的代码可以工作,那么 except 的部分会被跳过

  • 如果 try 中的代码不能工作,那么会跳转到 except 的部分

name = 'Bob'
try:
 print('hello')
 istr = int(name)
 print('there')
except:
 istr = -1
print('done', istr)  

使用多个 except 语句处理某种特殊情况的异常

try:
 ...
except ValueError:
 ...
except ZeroDivisionError:
...
except:
 ...

else & finally

else 在 try 中语句没问题时运行,finally 无论 try 中语句是否有错误都会执行。

raise

当出现错误时,显示错误条件。

在 Python 中,抛出一个 exception 使用 raise

格式:raise <exceptionName>(<arguments>)

raise Exception("descriptive string")

 

面向对象编程

class & object

class 是类的关键字,object 类是 Animal 的父类,__init__ 是创建实例的方法(注意双下划线 double underscore),self 代表该类的一个实例。

类中的数据成员和方法成员需要缩进。

class Animal(object):
 def __init__(self, age):
   self.age = age
   self.name = None
   
myAnimal = Animal(3)

不用给 self 提供参数,Python 会自动完成。

两种等价写法:

# 传统方法
c = Coordinate(3,4)
zero = Coordiante(0,0)
print(c.distance(zero))

# 等价写法
c = Coordinate(3,4)
zero = Coordinate(0,0)
print(Coordinate.distance(c,zero))

打印一个对象

c = Coordiante(3,4)
print(c)
<__main__.Coordinate object at 0x7..>
  • 默认是不详细的(uninformative)打印表示

  • 为一个类定义一个 __str__ 方法

  • 当打印一个对象时,Python 调用 __str__ 方法

  • 例如打印 <Coordinate.x , Cooridnate.y>

    class Coordinate(object):
     def __init__(self, x, y):
       self.x = x
       self.y = y
     def distance(self, other):
       x_diff_sq = (self.x-other.x)**2
       y_diff_sq = (self.y-other.x)**2
       return (x_diff_sq + y_diff_sq) ** 0.5
    def __str__(self):
       return "<"+str(self.x)+","+str(self.y)+">"

类型 & isinstance()

print(type(c))
# <class __main__.Coordiante> c 的类型是 Coordinate 类
print(Coordinate)
# <class __main__.Coordiante> Coordinate 是一个类
print(type(Coordinate))
# <type 'type'> Coordinate 也是一种对象

使用 isinstance() 查看某个变量是否为一个类的实例

print(isinstance(c, Coordinate))
# True

其它方法

__add__(self, other) # self + other
__sub__(self, other) # self - other
__eq__(self, other) # self == other
__lt__(self, other) # self < other
__len__(self, other) # len(self)
__str__(self, other) # print self

getter & setter

getter 用来返回类的属性,setter 用来设置类的属性。

class Animal(object):
 def __init__(self, age):
   self.age = age
   self.name = None
 def get_age(self):
   return self.age
def get_name(self):
   return self.name
def set_age(self, newAge):
   self.age = newAge
 def set_name(self, newName=""):
   self.name = newName
 def __str__(self):
   return "animal:" + str(self.name) + ":" + str(self.age)

dot natation

. 来访问属性(数据和方法)。

a.age
a.get_age()

Python 在信息隐藏方面的缺陷

以下行为都是不推荐的:

  • Python 允许在类定义外访问数据

    print(a.age)
  • Python 允许在类定义外修改数据

    a.age = 'infinite'
  • Python 允许在类定义外为一个实例创建属性

    a.size = "tiny"

默认参数

如果没有给定实参,那么给形参的默认参数会启用。

def set_name(self, newname=""):
 self.name = newname
 
a = Animal(3)
a.set_name()
print(a.get_name()) # ""

a = Animal(3)
a.set_name("fluffy")
print(a.get_name()) # 'fluffy'

继承

子类/派生类(child class) 可以继承父类/超类/基类(parent class / super class/ base class)

class Cat(Animal):
 def speak(self):
   print("meow")
 def __str__(self):
   return "cat:" + str(self.name) + ":" + str(self.age)

Cat 可以继承所有 Animal 的属性。

class Person(Animal):
 def __init__(self,name,age):
   Animal.__init__(self,age) # 调用父类构造函数
   self.set_name(name)
   self.friends = []  

类变量

class Rabbit(Animal):
 tag = 1 # 类变量
 def __init__(self,age,parent1=None,parent2=None):
   Animal.__init__(self,age)
   self.parent1 = parent1
   self.parent2 = parent2
   self.rid = Rabbit.tag # rid 是实例变量
   Rabbit.tag += 1

tag 用来给每个 Rabbit 实例独一无二的 id。

文件

一个文本文件可以被视为一系列行。

在读文件内容之前,我们必须告诉 Python 哪个文件能够使用并且我们要怎么做。这就需要 open() 函数。

open() 函数返回一个“文件句柄”–一个用于文件操作的变量。

这类似于 word 中 “文件->打开”。

handle = open(filename, mode),返回一个 handle 去操作文件,文件名是字符串。mode 是可选项,但是如果读文件应该用 ‘r’,如果写文件应该用 ‘w’。举例:fhand = open('mbox.txt', 'r')

换行符

使用换行符 \n 来表示一行的结尾。

换行符是一个字符,而不是两个。

stuff = 'x\ny'
print(stuff)
# x
# y

 

file handle 可以被视为字符串的序列,也就是说文件中任意一行都是字符串。所以我们可以使用 for 语句来迭代该序列。

注:一个序列是一个有序列表

xfile = open('mobx.txt')
for cheese in xfile:
 print(cheese)

计算文件的行数:

fhand = open('mbox.txt')
count = 0
for line in fhand:
 count = count + 1
print('line count ', count)

读取整个文件:

把文件的整个内容带着换行符一起读取

fhand = open('xx.txt')
inp = fhand.read()
print(len(inp))

过滤读取:

xfile = open('mobx.txt')
for cheese in xfile:
 cheese = cheese.rstrip()
 if cheese startswith('from'):
print(cheese)

读取不同的文件:

fname = input('enter file name: ')
fhand = open(fanme)
count = 0
for line in fhand:
if line startswith('sub'):
count = count + 1
print('there are ', count, 'subject lines in ', fname)

 

正则表达式

Python 中使用正则表达式需要导入包:

import re

使用 re.search() 来查看字符串是否匹配正则表达式,类似于使用 find() 在字符串中,返回一个布尔值,取决于是否匹配到了。

可以使用 re.findall() 去提取字符串和正则匹配的部分,返回一个列表,包含匹配的子串。

hand = open('xx.txt')
for line in hand:
 line = line.rstrip()
 if line.find('From') >= 0:
   print(line)
   
import re
hand = open('xx.txt')
for line in hand:
 line = line.rstrip()
 if re.search('From', line):
   print(line)

startswith() 相同,使用 ^

import re
hand = open('xx.txt')
for line in hand:
 line = line.rstrip()
 if re.search('^From', line):
   print(line)

. 匹配任何字符。* 匹配任何次数。+ 一个或更多。

: 最后一个匹配的字符

y = re.findall('[0-9]+', x)
print(y)

贪婪匹配会匹配最后一个出现的匹配。

非贪婪匹配会匹配第一个出现的匹配,使用 ?

 

网络

Sockets

Python 有内置的 TCP Sockets 支持

import socket
mysock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
mysock.connect(('data.pr4e.org', 80))
import socket

mysock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
mysock.connect(('data.pr4e.org', 80))
cmd = 'GET http://data.pr4e.org/romeo.txt HTTP/1.0\n\n'.encode()
mysock.send(cmd)

while True:
 data = mysock.recv(512)
 if (len(data) < 1):
   break
 print(data.decode())
mysock.close()  

字符串转字节

使用 .decode() 方法。

import socket

while True:
 data = mysock.recv(512)
 if (len(data) < 1):
   break
 mystring - data.decode()
 print(mystring)

 

使用 urllib

urllib 是一个库

import urllib.request, urllib.parse, urllib.error

fhand = urllib.request.urlopen('http://data.pr4e.org/remeo.txt')
for line in fhand:
 print(line.decode().strip())

 

Web 服务

有两种主流的数据交换格式:XML 和 JSON。

XML 和 XML Schema:

<person>
 <lastname>Severance</lastname>
 <age>17</age>
 <dateborn>2001-01-17</dateborn>
</person>

<xs:complexType name="person">
 <xs:sequence>
<xs:element name="lastname" type="xs:string" />
   <xs:element name="age" type="xs:integer" />
   <xs:element name="dateborn" type="xs:date" />
 </xs:sequence>
</xs:complexType>

JSON(JavaScript Object Notation):

import json
data = '''{
"name": "Chunk",
"phone": {
"type": "intl",
"number": "fsd"
},
"email": {
"hide": "yes"
}
}'''

info = json.loads(data)
print('Name:', info["name"])

Set

set 是一种保存不重复数据的结构。

使用 set() 构造一个 set,可以传入一个列表并去掉重复元素。

li = [1,2,3,1]
sets = set(li) // [1,2,3]
len(sets) // 3
 
版权声明:本文为risejl原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://www.cnblogs.com/risejl/p/16698599.html