Python实践摘录

1：中文编码问题

Python语言默认不识别UTF-8的编码字符串，所以当文件中有中文并且是以UTF-8编码时，需要在python文件头部加一行注释，指明识别utf-8编码.

# coding=utf-8
score = 90
if score>=80:
    print("很好")
elif score>=60:
    print("及格")
else:
    print("不及格")

 

2：字符串拼接

可以用 {0},{1}的形式占位，然后.format(对应下标位赋予内容)，如下：

#coding=utf-8
for i in range(0,100):
    print("item {0}{1}{2}".format(i," ","下标2内容"))

 

3：子类中调用父类构造方法、调用继承过来的内容

#coding=utf-8
class Hello:
    def __init__(self,name):
        self._name=name
    def sayHi(self):
        print "hello {0}".format(self._name)

class Hi(Hello):
    def __init__(self,name,age):
        #调用父类构造方法：父类名.__init__(self,参数)
        Hello.__init__(self,name)
        self._age=age
    def sayHiHi(self):
        #调用继承过来的内容，直接 self.内容 即可，因为继承过来了就是自己的了
        print "hi {0},{1}".format(self._name,self._age)

 

4：引用第三方模块

引用第三方模块可以通过import语句，引用后怎么使用呢？

法1：模块名.内容

import Hellolib
h=Hellolib.Hello() //引用的模块相当于一个命名空间
h.sayHello()

法2：在导入模块时指明导入具体的内容，则可以直接使用

from Hellolib import Hello
h=Hello()
h.sayHello()

注意：第一种方式引入后，如果不加模块名作前缀，会调用失败，报错：NameError: name '引用内容' is not defined

 

5：Python没有数组这种类型，只有列表和元组。

主要用法有：元组内容不可变、列表与元组的切片访问。

stu1=['a','b']
stu2=('a','b')
print stu1[0:]
print stu2[:1]

 

6：集合主要有两种功能：一是建立关系，二是去除重复。

 对于集合，可以用 & | - 进行集合的交、并、差操作。

a=set("abcdefgaaaaahik")
b=set("abcde")

print a
print b

c=a&b
print c

d=a|b
print d

e=a-b
print e

//结果：无序
set(['a', 'c', 'b', 'e', 'd', 'g', 'f', 'i', 'h', 'k'])
set(['a', 'c', 'b', 'e', 'd'])
set(['a', 'c', 'b', 'e', 'd'])
set(['a', 'c', 'b', 'e', 'd', 'g', 'f', 'i', 'h', 'k'])
set(['i', 'h', 'k', 'g', 'f'])

 

7：Python中没有map，而是用字典dict来表示关联数组，形式与java中的map一致：{key：value},操作也类似。

#创建一个dict
me={"name":"ygj0930","age":22,"address":"Guangzhou"}
print me

#添加一个键值对
me["new"]="new content"
print me

#修改一个已有的键值对
me["name"]="update name"
print me

#结果：无序！
{'age': 22, 'name': 'ygj0930', 'address': 'Guangzhou'}
{'new': 'new content', 'age': 22, 'name': 'ygj0930', 'address': 'Guangzhou'}
{'new': 'new content', 'age': 22, 'name': 'update name', 'address': 'Guangzhou'}

 

8：对象序列化与反序列化实践

把短暂的对象持久化地存储，这个过程称之为“腌制”，英文叫pickle，其实就是序列化。

Python提供两个模块来实现序列化：cPickle和pickle。这两个模块功能是一样的，区别在于cPickle是C语言写的，速度快，pickle是纯Python写的，速度慢，跟cStringIO和StringIO一个道理。用的时候，先尝试导入cPickle，如果失败，再导入pickle。

#coding=utf-8

#1：导入序列化模块cpickle/pickle
try:
    import cPickle as pickle
except ImportError:
    import pickle

dict={"name":"ygj","age":22,"addr":"Guangzhou"}
#2：有s的为对象与字符串相互转化
pickling=pickle.dumps(dict)
print pickling
unpickling=pickle.loads(pickling)
print unpickling

#3：无s的为序列化到文件、从文件反序列化
f1=file("pickling.txt","wb")
pickle.dump(dict,f1)
f1.close()#切记：写入文件后要关闭文件，才能把写到缓冲区的内容压入文件中

f2=file("pickling.txt","rb")
unpickling_from_f1=pickle.load(f2)
print unpickling_from_f1

 

9：分行

Python中，可以用回车进行物理分行，也可以在通过一代码行中用分号 ; 进行分行，一个分号表示一个语句的结束。

print "111" ;print "222";print "333"; #如果不加分号，就会报错

 

10：运算符实践

以下表格列出了从最高到最低优先级的所有运算符：

运算符	描述
**	指数 (最高优先级)
~ + -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //	乘，除，取模和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位 'AND'
^ |	位运算符
<= < > >=	比较运算符
<> == !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is ,is not	身份运算符
in, not in	成员运算符
not or and	逻辑运算符
lambda	lambda表达式

#coding=utf-8
#加号：两个对象相加，可以是数字相加，或者是字符串拼接
a=2+3
print "+:",a

b="Hi"+" ygj"
print "+:",b

#减号：取相反数，或者两数字相减
c=-7
print "-:",c
d=9-1
print "-:",d

#乘号：两个数字相乘，或者字符串重复n次
e=2*3
print "*:",e
f="yeah!"*3
print "*:",f

#幂运算：**
i=2**3
print "**:",i

#除号：两个数字相除，结果向两个运算数中高者看齐
g=7/2
print "/:",g
h=7.0/2
print "/:",h

#取商除法：// ，舍去余数，取商的整数部分
j=7//2
print "//:",j

#取余：%，返回余数
k=8%2
print "%:",k

#比较运算符：返回一个bool值结果
print 2<3
print 2>3
print 2!=3
print 2==3
print 2<=3
print 2>=3

#位运算
print "&:",2&3
print "|:",2|3
print "~:",~2

#左移、右移：左移相当于乘以2的n次方，右移相当于除以2的n次方
print 1<<3
print 1>>3

#逻辑运算:python中的逻辑运算是用英文表示的，没有java中的&& ||
print 2 and 3
print 2 or 3
print not 0

 

11：局部变量、全局变量、类的成员变量与静态变量

函数内定义的为局部变量，用global关键字声明的为全局变量。

#局部变量
def Hello():
    i=7
    print "i in func:",i
i=9
print "i in out:",i
Hello()

#全局变量
global j
j = 7
def Hi():
    print "global j in func:",j
Hi()
j=3#修改全局变量
print "j in out:",j
Hi()

#结果
i in out: 9
i in func: 7
global j in func: 7
j in out: 3
global j in func: 3

在类中，__init__()函数中定义的为类的成员变量，而在类体中定义的为类的静态变量。

class Test():
    #静态变量
    staticVar="I am static"
    def __init__(self,dynamic):
        #成员属性
        self.__dynamic=dynamic
    def say(self):
        print "dynamic:",self.__dynamic

test1=Test("I am the one")
print "static:",test1.staticVar
test1.say()

test2=Test("I am the two")
print "static:",test2.staticVar
test2.say()

结果：

static: I am static
dynamic: I am the one
static: I am static
dynamic: I am the two

 

12：多个函数返回值的接收

#coding=utf-8
#函数返回多个值
def count(x,y):
    return (x,y,x+y)
#用一个变量接收，则为元组
sum=count(1,2)
print sum
#用对应个数的变量接收，则对应赋值
num1,num2,sum=count(1,2)
print num1,"+",num2,"=",sum

结果：
(1, 2, 3)
1 + 2 = 3

 

13：文档字符串

在python中，可以定义一些说明性的字符串，用于描述函数的作用等。一般在函数的开头，用三引号书写文档字符串。在其他地方，可以用 func.__doc__()函数或help(func)获取函数的文档字符串。

文档字符串的书写有以下规范：

1：文档字符串必须在函数头的冒号 ：下一行开始书写
2：要用三引号括起文档字符串
3：第一行是函数功能概述，第二行必须空行，第三行开始就是函数功能的具体描述。
4：每一行以句号结尾
5：第一行开头如果是英文，要以大写开头。

#coding=utf-8
def count(x,y):
    ''' 这是一个求和函数。

    :param x:加数1
    :param y: 加数2
    :return: 和
    '''
    return (x,y,x+y)

print count.__doc__

结果：
 这是一个求和函数。

    :param x:加数1
    :param y: 加数2
    :return: 和
    

 

13：主模块实践

一个Python模块，相当于一个执行单元。

如果当前模块是主动执行的，就是主模块；如果是被其他模块引用而执行的，就是非主模块。

每个模块都有__name__属性，当该模块是主模块时，__name__属性值就是main。

因此，我们可以根据__name__=="main"判断一个模块是否为主模块，然后进行相应的操作定义。通过它，可以实现Java文件中的main函数一样的作用——提供程序入口并调用本模块中的其他函数。

#-*-coding=utf-8-*-
def fuc():
    print "this is func1"

if __name__ == '__main__':#如果是执行该模块，则是主模块，调用fuc()
    fuc()
else:
    print "this is not main"

运行该模块，结果为：this is func1

如果在其他模块引用该模块，则会执行else内容

import main

结果：this is not main

 

14：dir()获取模块、类、对象、函数的相关信息

#-*-coding=utf-8-*-
def fuc():
    print "this is func1"
print dir(fuc)

结果：
['__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__doc__',
'__format__', '__get__', '__getattribute__', '__globals__', '__hash__', '__init__', '__module__', '__name__',
'__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__',
'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name']

 

转载于:https://www.cnblogs.com/ygj0930/p/6950115.html