python 第3天课程笔记

Python中格式化输出字符串使用format()函数, 字符串即类, 可以使用方法;

Python是完全面向对象的语言, 任何东西都是对象;

字符串的参数使用{NUM}进行表示,0, 表示第一个参数,1, 表示第二个参数, 以后顺次递加;

使用:, 指定代表元素需要的操作, 如:.3小数点三位, :8占8个字符空间等;

数字(0, 1, ...)即代表format()里面的元素, 所以可以使用.调用元素的方法;

 

# -*- coding: utf-8 -*-

 

#====================

#File: abop.py

#Author: caofengzhen


#Date: 2016-1-18

#====================

 

#eclipse pydev, python3.3

 

age = 25

name = 'Caroline'

 

print('{0} is {1} years old. '.format(name, age)) #输出参数

print('{0} is a girl. '.format(name))

print('{0:.3} is a decimal. '.format(1/3)) #小数点后三位

print('{0:_^11} is a 11 length. '.format(name)) #使用_补齐空位

print('{first} is as {second}. '.format(first=name, second='Wendy')) #别名替换

print('My name is {0.name}'.format(open('out.txt', 'w'))) #调用方法

print('My name is {0:8}.'.format('Fred')) #指定宽度

 

输出：

Caroline is 25 years old.

Caroline is a girl.

0.333 is a decimal.

_Caroline__ is a 11 length.

Caroline is as Wendy.

My name is out.txt

My name is Fred    .

 

扩展：

s1 = "{0} is {1}"l = ["a","sb"]

result0 = s1.format("a","sb")

print(result0)result1 = s1.format(*l)

print(result1)

s2 = "{key} is {value}"

result2 = s2.format(key="a",value="sb")

print(result2)

d = {'key':'a','value':'sb'}

result3 = s2.format(**d)

print(result3)

输出：a is sb
------------------------------------------------------------------------------------------
lambda

lambda语句中，冒号前是参数，可以有多个，用逗号隔开，冒号右边的返回值。lambda语句构建的其实是一个函数对象。

 

举例：

def add(a):
    b= a+1
    return b

add_1 = lambda a: a+1
print(add_1(4)) #=> 与下面函数调用等价
print(add(4))

def add(x,y):return x+y
add2 = lambda x,y:x+y
print add2(1,2)     #=>3
------------------------------------------------------------------------------
set

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。要创建一个set，需要提供一个list作为输入集合（其实字符串也可以）：

x = set('spam')
>>> y = set(['h','a','m'])
>>> x, y
>>>({'s', 'a', 'p', 'm'}, {'m', 'a', 'h'})
l_1=set({1:'a',2:'b'})
print(l_1) #=>{1, 2}

再来些小应用。 

>>> x & y # 交集  => {'a','m'}

>>> x | y # 并集  => {'a', 'p', 's', 'h', 'm'}

>>> x - y # 差集  => {'p', 's'}

 

方法

a = t | s          # t 和 s的并集  

b = t & s          # t 和 s的交集  

c = t – s          # 求差集（项在t中，但不在s中）  

d = t ^ s          # 对称差集（项在t或s中，但不会同时出现在二者中）  

基本操作：  

t.add('x')            # 添加一项  

s.update([10,37,42])  # 在s中添加多项  

使用remove()可以删除一项：  

t.remove('H')  

len(s)  

set 的长度  

 

x in s  

测试 x 是否是 s 的成员  

 

x not in s  

测试 x 是否不是 s 的成员  

 

s.issubset(t)  

s <= t  

测试是否 s 中的每一个元素都在 t 中  

 

s.issuperset(t)  

s >= t  

测试是否 t 中的每一个元素都在 s 中  

 

s.union(t)  

s | t  

返回一个新的 set 包含 s 和 t 中的每一个元素  

 

s.intersection(t)  

s & t  

返回一个新的 set 包含 s 和 t 中的公共元素  

 

s.difference(t)  

s - t  

返回一个新的 set 包含 s 中有但是 t 中没有的元素  

 

s.symmetric_difference(t)  

s ^ t  

返回一个新的 set 包含 s 和 t 中不重复的元素  

 

s.copy()  

返回 set “s”的一个浅复制 

----------------------------------------------------------------------

计数器（Counter）是一个容器，用来跟踪值出现了多少次。和其他语言中的bag或multiset类似。

计数器支持三种形式的初始化。构造函数可以调用序列，包含key和计数的字典，或使用关键字参数。

importcollections

 

printcollections.Counter(['a', 'b', 'c', 'a', 'b', 'b'])

printcollections.Counter({'a':2, 'b':3, 'c':1})

printcollections.Counter(a=2, b=3, c=1)

 

执行结果：

 

Counter({'b':3, 'a': 2, 'c': 1})

Counter({'b':3, 'a': 2, 'c': 1})

Counter({'b':3, 'a': 2, 'c': 1})

 

__author__ = 'cfengzhe'
import collections

obj = collections.Counter("aaaabbbbdddeesserer221333")
for k,v in obj.items():
    print(k,v)
for k in obj.elements():
    print(k)
print(obj)
dic = {1:'a',2:'b',50:'c'}
#print(sorted(dic))
#counter ye ke yi yong list zuowei canshu
dic.pop(1)
print(dic)
dic.update({3:'e'}) #ye keyi jia duoge
print(dic)

 输出：

a 4
s 2
1 1
2 2
b 4
d 3
3 3
e 4
r 2

a
a
a
a
s
s
1
2
2
b
b
b
b
d
d
d
3
3
3
e
e
e
e
r
r

Counter({'a': 4, 'b': 4, 'e': 4, 'd': 3, '3': 3, 's': 2, '2': 2, 'r': 2, '1': 1})

{2: 'b', 50: 'c'}

{2: 'b', 3: 'e', 50: 'c'}
--------------------------------------------------------------------------------------------------------

 

__author__ = 'cfengzhe'
#-*-coding:utf-8 -*-
import collections
MyTupleClass = collections.namedtuple("MyTupleClas",['a','b','c'])
obj = MyTupleClass(11,22,33)
print(obj.a)
print(obj.b)
print(obj.c)

#参数是列表
t = [11,22,33]
p  = MyTupleClass._make(t)
print(p)
print(p.b)

#参数是字典
d = {'a': 44, 'b': 55,'c':66}
dp = MyTupleClass(**d)
print(dp)
print(dp.a)

----------------------------------------------------------

__author__ = 'cfengzhe'
#-*-coding:utf-8 -*-
import copy

n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}

n4 = copy.deepcopy(n1)
print(id(n1))
print(id(n4))
#以上两个不同
print(id(n1['k2']))
print(id(n4['k2']))
#以上两个相同，因为是数字或者字符串
print(id(n1['k3']))
print(id(n4['k3']))
#以上两个不同，因为是list

#实际应用在监控项目的修改中，如果用浅的copy,在赋值就都给改了。。
dic = {'cpu':[80,],
       'mem':[80,],
       'disk':[80,]
       }
new_dic = copy.deepcopy(dic)
new_dic['disk'][0] = 50
print(dic)
print(new_dic)

#总结，凡是字符或者字符串他们的内存地址都是相同的

输出：
6680904
7064008
1500774000
1500774000
7503048
7501768
{'cpu': [80], 'disk': [80], 'mem': [80]}
{'cpu': [80], 'disk': [50], 'mem': [80]}