Python 特性语法总结
成员运算符
| 运算符 | 描述 |
|---|---|
| in | 在指定的序列中找到值，返回True；否则返回False |
| not in | 相反 |
a = 10
list = [1,2,3,4,5]
if (a in list):
print(a)
if (a not in list):
print(0)
身份运算符
| 运算符 | 描述 |
|---|---|
| is | x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False |
| is not | 相反 |
is 与 == 区别：
is用于判断两个变量引用对象是否为同一个，==用于判断引用变量的值是否相等。
字符串格式化
print ("我叫 %s 今年 %d 岁!" % ('小明', 10))
//我叫 小明 今年 10 岁!
主要使用format()格式化函数
print("name:{a},addr{b}".format(a='haha',b='home')
数据结构
1.列表
-
del关键字
del list[0]
del list -
函数
| 操作 | 含义 |
|---|---|
| max(list) / min(list) | 返回最值 |
| list(seq) | 将元组转换为列表 |
| cmp(list1,list2) | 比较两个列表的元素 |
| len(list) | 长度 |
- 脚本操作符
| 操作 | 含义 |
|---|---|
+ |
组合 |
* |
重复 |
in |
元素是否存在于列表中 |
- 方法
| 操作 | 含义 |
|---|---|
| list.append(obj) | 末尾添加 |
| list.count(obj) | 统计某个元素在列表中出现的次数 |
| list.extend(seq) | 用新列表扩展原来的列表 |
| list.index(obj) | 第一个匹配项的索引位置 |
| list.insert(index, obj) | 将对象插入列表 |
| list.pop([index = -1]) | 默认移除最后一个元素并返回元素值 |
| list.remove(obj) | 移除第一个匹配项 |
| list.reverse() | 元素反向 |
| list.sort(cmp=None, key=None, reverse=False) | 根据规则排序 |
2. 元组
#!/usr/bin/python
# -*- coding: UTF-8 -*-
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
# 创建一个新的元组
tup3 = tup1 + tup2
print tup3
#输出(12, 34.56, 'abc', 'xyz')
del不允许删除元组中的元素，但是可以删除整个元组
内置函数
- cmp(tuple1,tuple2)
- len(tuple)
- max(tuple) / min(tuple)
-
tuple(seq)将列表转换为元组
3. 字典
字典是另一种可变容器模型，且可存储任意类型对象。
- 键唯一，值不需要唯一
- 若同一个键出现两次，则后一个值被记住
- 键不可变，因此
不可以用列表作为键
| 操作dict | 含义 |
|---|---|
| del dict['a'] | 删除键是'a'的条目 |
| dict.clear() | 清空字典条目 |
| del dict | 删除字典 |
| cmp(dict1,dict2) | 比较 |
| len(dict) | 计算字典元素个数，键数 |
| str(dict) | 返回字典的字符串表示，方便打印 |
| dict.has_key(key) | 如果键在字典dict里返回true，否则返回false |
| dict.items() | 以列表返回可遍历的(键，值)元组数组 |
| dict.keys() | 以列表返回所有键 |
| dict.values() | 以列表返回字典中所有值 |
| dict.update(dict1) | 把另一个字典dict1的键值对更新到dict里 |
| dict.pop(key[,default]) | 删除键值对，并弹出key对应的值，不给key则返回default值 |
| dict.popitem() | 返回并删除字典中最后一对键值(元组） |
遍历技巧
-
字典遍历同时解读键和值：items()
dic = {'keya':'valuea', 'keyb':'valueb'}
for k,v in dic.items():
print(k,v)
"""
输出
keya valuea
keyb valueb
"""
-
列表遍历同时得到索引位置和对应值：enumerate()
for i, v in enumerate(['a', 'b', 'c']):
print(i,v)
"""
输出
0 a
1 b
2 c
"""
- 同时遍历两个及以上
列表：zip()
list1 = ['a1', 'b1', 'c1']
list2 = ['a2', 'b2', 'c2']
for x, y in zip(list1, list2):
print('list1 {0} and list2 {1}'.format(list1,list2)
"""
输出
list1 a1 and list2 a2
list1 b1 and list2 b2
list1 c1 and list2 c2
"""
- 反序遍历：reversed()
for i in reversed(range(1,10,2)):
print(i)
"""
输出
9
7
5
3
1
"""
函数传参
可变对象与不可变对象
python中一切都是对象，严格意义我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象。
不定长参数
一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数。
- 加了
*号的参数会以元组（tuple）的形式导入（可以不传递未命名的变量导入空元组），存放所有未命名的变量参数。
注意：定义函数时参数前加*，若是在调用函数时参数前加*有解包裹的效果
https://www.cnblogs.com/bingabcd/p/6671368.html - 带两个星号
**的参数会以字典的形式导入。 - 注意区别参数表中单独出现的*，作用是其后的参数必须用关键字传入。
匿名函数lambda
lambda只是一个表达式，函数体比def简单很多。
语法：
lambda [arg1 [,arg2,……,argn]]:expression
demo
sum = lambda arg1, arg2: arg1 + arg2
#调用
print(sum(1,2))
#输出
#3
迭代器与生成器
迭代是python访问集合元素的一种方式。
- 迭代器是一个可以记住遍历的位置的对象。
- 迭代器只能往前不会后退。
- 两个基本方法 iter()和next()
- 字符串、列表、元组对象都可用于创建迭代器
迭代器
- 由列表创建迭代器对象(导入sys模块)
#!/usr/bin/python3
import sys # 引入 sys 模块
list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
while True:
try:
print (next(it))
except StopIteration:
sys.exit()
#输出结果
#1
#2
#3
#4
- 把类作为迭代器使用
需要在类中实现两个方法
1.__iter__()
返回一个迭代器对象，这个对象实现了__next()__方法并通过StopIteration异常标识迭代的完成。
2.__next__()
返回下一个迭代器对象
实例：创建一个返回数字的迭代器，初始值为1，逐步增1
class MyNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
x = self.a
self.a += 1
return x
myclass = MyNumbers()
myiter = iter(myclass)
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
#输出结果
#1
#2
#3
#4
#5
StopIteration
在20次迭代后停止执行
class MyNumbers:
def __iter__(self):
self.a = 1
return self
def __next__(self):
if self.a <= 20:
x = self.a
self.a += 1
return x
else:
raise StopIteration
myclass = MyNumbers()
myiter = iter(myclass)
for x in myiter:
print(x)
#输出1到20
生成器 yield
使用了yield的函数被称为生成器(generator)。
- 此类函数返回的是迭代器，只能用于迭代操作。
- 每次遇到yield时函数会暂停并保存当前所有的运行信息，返回yield的值，并在下次执行next()方法时从当前位置继续运行。
实例：使用yield实现斐波那契数列
#!/usr/bin/python3
import sys
def fibonacci(n): # 生成器函数 - 斐波那契
a, b, counter = 0, 1, 0
while True:
if (counter > n):
return
yield a
a, b = b, a + b
counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
while True:
try:
print (next(f), end=" ")
except StopIteration:
sys.exit()
#输出结果
#0 1 1 2 3 5 8 13 21 34 55
模块
命令行中参数的使用
使用模块: sys
import sys
for i in sys.argv:
print(i)
- sys.argv 是一个包含命令行参数的列表
- sys.path 包含了一个Python解释器自动查找所需模块的路径的列表。
__name__属性
一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被以引入时，模块中的某一程序块不执行，可以使用__name__属性。
__name__属性使该程序块仅在该模块自身运行时执行。
#!/usr/bin/python3
# Filename: using_name.py
if __name__ == '__main__':
print('程序自身在运行')
else:
print('我来自另一模块')
输出
$ python using_name.py
程序自身在运行
$ python
>>> import using_name
我来自另一模块
>>>
输入和输出
repr()
产生一个解释器易读的表达式
# repr() 函数可以转义字符串中的特殊字符
hello = 'hello, runoob\n'
hellos = repr(hello)
print(hellos)
输出
'hello, runoob\n'
# repr() 的参数可以是 Python 的任何对象
repr((x, y, ('Google', 'Runoob')))
返回
"(32.5, 40000, ('Google', 'Runoob'))"
关于字符串对象的格式化方法
- string.rjust(num) 字符串靠右，左边填充num个空格
for x in range(1,11):
print(repr(x).rjust(2), repr(x*x).rjust(3))
for x in range(1, 11):
print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
输出
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
- string.ljust()/center()
- string.zfill(num)在数字的左边填充num个0
读和写文件
-
open()
基本语法open(filename, mode)
mode：决定了文件的打开模式，非强制，默认为只读(r)。
f = open("1.txt") -
f.read(size)
size:读取数目，可选参数，空则读取并返回所有内容。 -
f.readline()
从文件中读取单独的一行。换行符为'\n'。若返回一个空字符串则说明已读取到最后一行。 -
f.readlines()
返回文件中包含的所有行。
如果设置可选参数sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。 -
f.write()
f.write(string) 将 string(字符串类型) 写入到文件中, 然后返回写入的字符数。 -
f.tell()
返回文件对象当前所处的位置，它是从文件开头开始算起的字节数。 -
f.seek()
改变文件当前的位置
seek(x,0) ： 从起始位置即文件首行首字符开始移动 x 个字符
seek(x,1) ： 表示从当前位置往后移动x个字符
seek(-x,2)：表示从文件的结尾往前移动x个字符 -
f.close()
关闭文件并释放系统的资源。
当处理一个文件对象时, 使用 with 关键字是非常好的方式。在结束后, 它会帮你正确的关闭文件。 而且写起来也比 try - finally 语句块要简短:
with open('/tmp/foo.txt', 'r') as f:
read_data = f.read()
f.closed
True
网友评论