第一个Python程序
print('Hello World!')
变量 Variables
my_variable = 10
布尔值 Booleans
my_int = 7
my_float = 1.23
my_bool = True
格式
在Python中利用空格控制缩进来达到代码分块的效果（诸如Java中利用'{}'来进行代码分块），这是很重要的。
一般使用4个空格来进行换行的缩进。
Python使用#进行单行注释。
# 这是一段注释
mysterious_variable = 42
使用如下结果进行多行注释
'''
这是一段注释。
'''
数学计算
Python实现数值计算的方式很简单，跟MATLAB很像。
addition = 72 + 23
subtraction = 108 - 204
multiplication = 108 * 0.5
division = 108 / 9
eight = 2 ** 3 #幂计算
modulo = 3 % 2 #取模计算
字符串 String
Python利用两个双引号""，或者两个单引号''包裹字符串
caesar = "Graham"
praline = "John"
viking = "Teresa"
在Python中利用空格控制缩进来达到代码分块的效果（诸如Java中利用中，如果字符串中有'，"，\等，需要在它们面前增加\进行转义，此时字符串才能正常解释。
选取字符串中的某个字符，只需要传入相应字符的下标即可。Python中的下标从0开始
fifth_letter = "MONTY"[4] #取出字母Y
常见的字符串函数
len() 返回字符串长度
len(string)lower() 返回小写的字符串
string.lower()upper() 返回大写的字符串
string.upper()str() 将非字符串类型转化为字符串类型
str(2)isalpha() 判断字符串是否只由字母组成
string.isalpha()
字符串拼接
Python中利用+进行多个字符串之间的拼接；非字符串类型需要转化为字符串类型之后才能进行拼接。
print "The value of pi is around " + str(3.14)
字符串切片
new_word = new_word[1:len(new_word)]
打印 Print
在python3+中，利用print()进行打印信息。
print("Hello World!")
在打印字符串的时候，字符串后面跟着一个,后打印结果会输出一个空格。
格式化输出
string_1 = "Camelot"
string_2 = "place"
print "Let's not go to %s. 'Tis a silly %s." % (string_1, string_2)
日期和时间 Date and Time
- 导入日期时间库
from datetime import datetime
- 打印当前时间
print(datetime.now())
- 获取日期的年、月、日
datetime.now().year
datetime.now().month
datetime.now().day
- 获取时间的时、分、秒
datetime.now().hour
datetime.now().minute
datetime.now().second
流程控制
- 逻辑运算符
= 等于
!= 不等于
< 小于
<= 小于等于
> 大于
>= 大于等于
== 两个变量之间比较是否相同(内存地址值比较)
and 与
or 或
not 非
if...elif...else...结构
def greater_less_equal_5(answer):
if answer > 5:
return 1
elif answer < 5:
return -1
else:
return 0
函数 Function
函数定义格式
def hello_world():
"""Prints 'Hello World!' to the console."""
print "Hello World!"
def power(base, exponent):
result = base**exponent
print("%d to the power of %d is %d." % (base, exponent, result))
power(37, 4)
匿名函数 lambda
sum = lambda arg1, arg2: arg1 + arg2; 定义一个sum函数
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
导入模块
import math
print(math.sqrt(25))
from math import sqrt
# from math import *
print(sqrt(25))
查看模块下的函数
import math
print(dir(math))
max() 返回序列中的最大值
max(1, 2, 3)min() 返回序列中的最小值
min(1, 2, 3)abs() 返回绝对值
abs(-1)type() 返回变量类型
type('abc')range() 返回一个范围的数值序列
from random import randint
randint(0, 10) #产生一个范围内的随机整数
列表和字典 Lists and Dictionaries
zoo_animals = ["pangolin", "cassowary", "sloth", "tiger"] 定义一个列表，列表下标从0开始
修改列表
zoo_animals[2] = "hyena"
append() 添加元素到列表
len() 计算列表元素个数
index() 返回寻找的元素下标
insert() 在index位置插入一个元素
sort() 列表中的元素进行排序
pop() 从列表中删除元素，依据下标进行
remove() 从列表中删除元素，依据元素进行
del() 从列表中删除元素
join() 拼接列表元素
sorted([5, 2, 3, 1, 4])
列表切片
zoo_animals[1:5] 选取列表中的下标为1到4的元素
my_list = range(1, 11) my_list[::2] 以步长为2遍历列表元素
my_list = range(1, 11) my_list[::-1]逆序排序列表元素
字符串是特殊的列表
遍历列表
for animal in animals:
print(animal)
列表推导式
[i for i in range(51) if i % 2 == 0]
residents = {'Puffin' : 104, 'Sloth' : 105, 'Burmese Python' : 106} 定义一个字典
items() 以列表返回可遍历的(键, 值) 元组数组
dict.items()keys() 以列表返回一个字典所有的键
dict.keys()values() 以列表返回字典中的所有值
dict.values()
取出字典元素
residents['Puffin']
添加元素到字典
residents['Jason'] = 100
更改字典元素
residents['Puffin'] = 114
删除字典元素
del residents['Jason']
- remove() 删除字典元素
循环 Loops
- while循环
打印1到10的平方数
num = 1
while num <= 10:
print(num ** 2)
num += 1
while循环中可以添加else块
- break 关键字
跳出循环
count = 0
while count < 3:
num = random.randint(1, 6)
print num
if num == 5:
print "Sorry, you lose!"
break
count += 1
else:
print "You win!"
- for 循环
for i in range(20):
print i
fruits = ['banana', 'apple', 'orange', 'tomato', 'pear', 'grape']
print 'You have...'
for f in fruits:
if f == 'tomato':
print 'A tomato is not a fruit!' # (It actually is.)
print 'A', f
else:
print 'A fine selection of fruits!'
- zip() 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用*号操作符，可以将元组解压为列表。
list_a = [3, 9, 17, 15, 19]
list_b = [2, 4, 8, 10, 30, 40, 50, 60, 70, 80, 90]
for a, b in zip(list_a, list_b):
if a > b:
print(a)
else:
print(b)
- 递归
def factorial(x):
if x == 0:
return 1
return factorial(x - 1) * x
* 计算素数
```python
def is_prime(x):
if x <= 1:
return False
if x == 2:
return True
if x % 2 == 0:
return False
n = 3
while n * n <= x:
if x % n == 0:
return False
n += 2
return True
- 字符串逆序
def reverse(text):
result = ""
i = len(text) - 1
while i >= 0:
result = result + text[i]
i -= 1
return result
reverse('Python')
位操作 Bitwise Operators
print(5 >> 4) # 0101 --> 0000，结果为0
print(5 << 1) # 0101 --> 1010，结果为10
print(8 & 5) # 1000 & 0101，结果为0
print(9 | 4) # 1001 | 0100，结果为13
print(12 ^ 42) # 001100 ^ 101010，结果为38(100110)
print(~88) # 1011000 --> 0100111，结果为-89
print(0b1) # 1
print(0b10) # 2
print(0b11) # 3
print(0b100) # 4
print(0b101) # 5
print(0b110) # 6
print(0b111) # 7
print(0b1 + 0b11)
print(0b11 * 0b11)
bin() 函数 返回一个整数int或者长整数long int的二进制表示
int() 函数 将一个二进制数转化为十进制
int("11001001", 2)
掩码
def check_bit4(input):
mask = 0b1000
desired = input & mask
if desired > 0:
return 'on'
else:
return 'off'
def flip_bit(number, n):
mask = (0b1 << n - 1)
result = number ^ mask
return bin(result)
类 Clsaaes
定义一个类
# 定义一个类
class Animal(object):
"""Makes cute animals."""
health = "good"# 全局变量
# 初始化对象
def __init__(self, name, age, is_hungry):# self参数指代object，即对象本身
self.name = name
self.age = age
self.is_hungry = is_hungry
zebra = Animal("Jeffrey", 2, True)#建立一个Animal类对象
giraffe = Animal("Bruce", 1, False)
panda = Animal("Chad", 7, True)
print(zebra.name, zebra.age, zebra.is_hungry)
print(giraffe.name, giraffe.age, giraffe.is_hungry)
print(panda.name, panda.age, panda.is_hungry)
- 全局变量 global variables
作用于全部类对象
- 局部变量/实例变量 member variables
作用于某些类对象
- 定义类方法和调用方法
class Animal(object):
"""Makes cute animals."""
is_alive = True
def __init__(self, name, age):
self.name = name
self.age = age
# Add your method here!
def description(self):
print(self.name)
print(self.age)
hippo = Animal("hippo", 12)
hippo.description()
- 继承 Inheritance
Triangle类继承子Shape类
class Shape(object):
"""Makes shapes!"""
def __init__(self, number_of_sides):
self.number_of_sides = number_of_sides
class Triangle(Shape):
def __init__(self, side1, side2, side3):
self.side1 = side1
self.side2 = side2
self.side3 = side3
* 复写 override
PartTimeEmployee类继承自Employee类，但是创建PartTimeEmployee对象的时候，因为PartTimeEmployee中有与Employee类同名的方法，此时只使用PartTimeEmployee的同名方法。
class Employee(object):
"""Models real-life employees!"""
def __init__(self, employee_name):
self.employee_name = employee_name
def calculate_wage(self, hours):
self.hours = hours
return hours * 20.00
class PartTimeEmployee(Employee):
def calculate_wage(self, hours):
self.hours = hours
return hours * 12.00
* super()函数 用于调用下一个父类(超类)并返回该父类实例的方法【python2和python3之间存在差异，此处为python3的】
#父类
Class Parent():
def __init__(self,attribute):
#子类
Class Child(Parent):
def __init__(self,attribute):
super().__init__(attribute)
* __repr__()函数 用于格式化表示对象
class Point3D(object):
def __init__(self, x, y, z):
self.x = x
self.y = y
self.z = z
def __repr__(self):
return "(%d, %d, %d)" % (self.x, self.y, self.z)
my_point = Point3D(1, 2, 3)
print my_point.__repr__()
文件输入/输出 File Input/Output
* open()函数 打开文件
f = open("output.txt", "w") # 以write模式写文件
my_file = open('output.txt', 'r+') # 以read和write模式处理文件
* write()函数 写入文件 close()函数 关闭文件
my_list = [i**2 for i in range(1,11)]
my_file = open("output.txt", "r+")
for i in my_list:
my_file.write(str(i))
my_file.write('\n')
my_file.close()
* read() 函数 读取文件
my_file = open('output.txt', 'r+')
print(my_file.read())
my_file.close()
* readline() 函数 读取文件的一行
my_file = open('text.txt', 'r')
print(my_file.readline())
my_file.close()
* with...as... 关键字 流式处理文件，自动关闭文件流，不需要引用close()函数关闭文件
with open("text.txt", "w") as textfile:
textfile.write("Success!")
* closed 函数 确定文件操作是否关闭
my_file = open('text.txt', 'w')
if my_file.closed:
print(my_file.closed)
else:
my_file.close()
print(my_file.closed)
