C++转python2语法

和C/C++相同特性的基础语法不在阐述

print "hello"
print 'hello'

单引号也可以表示字符串

print "hello \
world"

斜杠表示两个字符串是连在一起的组成"hello world"

s = r"hello world\n"
print s

r 自然字符串 表示不进行转义处理

print u"hello world"

u 表示为unicode编码字符串

print "hello" "world"

自动合并两个字符串常量 会输出helloworld

print "hello" "world" #输出hello world
'''
多行注释
多行注释
多行注释
'''

python注释方法

python使用4个制表符作为缩进标准 每个逻辑行认为是一个语句

#-*- coding utf-8 -*-

写在第一行 设置编码格式

a = input()
b = input("please input:")

接受两个整数 第一个无提示 第二个带提示

print "a + b = ", a + b

print同时输出多个类型

print "abc " * 5 #输出5个abc

字符串和数值相乘等于多个字符串

print 2 ** 10 #输出2的10次方
print 3 / 2 #输出1
print 3.0 / 2.0 #输出1.5
print 3 // 2 #输出1
print 3.0 // 2.0 #输出1.0
a = 2
b = 3
a, b = b, a + b #先计算右侧的数值再对应的赋给左边 可用于fib递推
print a, b #3 5

次方与整除运算符

a <> b #判断a和b不等 相当于!=

判断不等

True
False

python的true和false需要首字母大写

a and b
a or b
not a

python逻辑运算符 与或非 遵循短路现象

ls = [1, 2, 3]
print 1 in ls #输出True
print 5 in ls #输出False

成员运算符 判断一个元素是否在一个列表当中

a = 1
b = 1
c = 2
print id(a)
print id(b)
print id(c)
print a is b
print a is c
print a is not b
print a is not c

身份运算符 id返回对象的内存地址 is判断两个标识符是否引用自同一个对象 is not判断是否引用自不同对象

a = b = c = d = e = 1
if (a):
	b
elif (c): #else if
	d
else:
	e

控制语句 注意后面加冒号

a = input() #接受整数 如果接受字符串需要加引号
a = raw_input() #接受字符串

input和raw_input的区别

type(a) #返回对象的类型

获取对象类型函数

a = [1, 2, 3]
print len(a)
s = "abcde"
print len(s)

获取字符串长度或获取数列元素数

a = b = 1
while a != b:
    print a
else:
    print a
    
for i in range(10): #range(10)返回一个0到9的序列 i循环序列中的额数值共10次
    print a
else:
    print a

循环语句 如果循环正常退出没被break则执行else内容

for i in range(3, 10, 2):
    print i

range函数 返回一个序列 参数abc只有a表示[0, a) 有ab表示[a, b) 有abc表示[a, b)并且步长为c

f = [0, 1]
for i in range(11):
    if (i >= 2):
        f.append(f[i - 1] + f[i - 2])
    print f[i], #输出之间加空格

输出斐波那契前0到10项

def myprint(x):
    print x

a = input()
myprint(a)

定义一个带参数x的函数

def solve(a, b = 10, c = 20):
    print a, b, c

solve(5, c = 30) #指明给c参数传参

多个参数的函数和参数默认值 和关键参数

def solve():
    global x
    x = 5

x = 2
print x #输出2
solve()
print x #输出5

global在函数内声明一个全局变量 用于在函数内访问全局变量

python中在函数内的变量为局部变量 不在函数内的变量为全局变量

def add(a, b):
    return a + b

print add(2, 3)

return使函数返回一个值 没return的函数返回None

def add(a, b):
    '''返回a + b的结果'''
    return a + b

print add.__doc__
help(add)

文档字符串 给函数增加一个帮助文档并输出

def LeapYear(y):
    if (y % 400 == 0 or y % 100 != 0 and y % 4 == 0):
        return True
    return False

y = input()
print LeapYear(y)

判断输入的年份是否为闰年

import my

导入my.py模块并声称my.pyc加速下次导入

import sys #导入标准模块
print sys.argv #返回一个令行参数列表 0为自身
print sys.path #输出系统环境变量包括自身路径
sys.exit(0) #结束程序并返回0

调用sys标准模块

from sys import path
print path

从sys模块中启用一个path的变量 调用不需要sys.即可

import sys as s
print s.path

调用sys模块并建立别名s

if __name__ == "__main__" :

当模块直接被运行时表达式为真 被import为假

len(sys.argv) #命令行参数个数
print sys.argv[0] #程序名
print sys.argv[1] #第一个参数
print sys.argv[2] #第二个参数

获取命令行参数

print dir() #当前模块
print dir("sys") #指定模块

dir函数 返回模块的可用属性列表

a = 1
del a

删除一个对象

import time

def Run(fun): #参数也可以是个函数
    st = time.time();
    fun()
    return time.time() - st

def ListAppend():
    ls = [] #创建一个空列表
    for i in range(1000):
        for j in range(1000):
            ls.append(j)

def ListExtend():
    ls = []
    seq = range(1000)
    for i in range(1000):
        ls.extend(seq) #将seq列表加入到ls中

print "ListAppend :", Run(ListAppend) #比较两个函数的运行时间
print "ListExtend :", Run(ListExtend)

print time.strftime("%Y/%m/%d %H:%M:%S") #输出 年/月/日 时:分:秒
time.sleep(2) #进程休眠5秒

time标准模块的使用

ls = []                         #创建一个空的列表
ls = [1, "string", [1, 2, 3]]   #列表可以同时拥有多个类型的元素
print len(ls)                   #返回列表元素数量 3
ls.append(1.5)                  #在尾部插入一个新的元素
print ls
ls.sort()                       #将列表按照字典序排序
print ls
del ls[1]                       #删除下标为1的元素 .pop(idx)删除并返回
print ls
ls[1].append(4)                 #操作某个元素
print ls
ls2 = ['x', 'x']
ls.extend(ls2)                  #将ls2中的元素加入到末尾
print ls
print ls.index('x')             #返回首个符合条件的元素的下标 无则返回错误
print ls.count('x')             #统计复合条件的元素个数
ls.remove('x')                  #删除首个符合条件的元素 无则返回错误
print ls
str = "string"
ls = list(str) #将字符串转为列表
print ls

列表的基本操作

tup = (1, "string", [1.1, 1.2])
#del tup[0] #Error 元组无法修改
#tup[0] = 2 #Error
tup[2].append(1.3)
print tup
print len(tup)
ls = [1, 2]
tup = tuple(ls) #将列表转换为元组
print tup
del tup 

元组的基本操作 元组及元组的元素无法修改

x = 10
s = "num"
print "%s:%d" %(s, x) #num:10

print格式说明符 使用元组打印

tup1 = (1, 2)
tup2 = (3.0, 4.0)
tup3 = tup1 + tup2
print tup3

令tup3等于tup1+tup2

mp = {"a" : 0, "b" : 1, "c" : 2}
print len(mp) #输出3
print mp["b"]
mp["d"] = 4
del mp["b"] #删除某个元素 .pop(key)删除并返回val
print mp
for fst, sed in mp.items(): #遍历整个字典
    print "%s : %d" %(fst, sed)
print "a" in mp #判断键值是否存在 mp.has_key("a")
print "b" in mp
mp.clear() #清空字典
print mp

字典的基本操作

s = "x123xx"
print s.startswith("x1") #True 判断是否以某个串为开头
print s.endswith("3x") #False 判断是否以某个串为开头
print s.find("3x") #查找串出现位置 未找到-1
s2 = "-"
s3 = s2.join(s) #返回一个串 每个字符用s2分隔
print s3 #x-1-2-3-x-x
s4 = s3.replace("-", " ") #将字符串中所有的"-"换为空格
print s4 #x 1 2 3 x x
ls = ["abc", "xyz"]
print s2.join(ls) #abc-xyz 返回一个串 每个元素用-分隔
print s.count("xx") #1 查找串出现次数
print s.isalpha() #False 判断串是否都为字母
print s.isdigit() #False 判断串是否都为数字
print s.isalnum() #True 判断串是否都为字母或数字
print s.islower() #True 若有字母 判断串中所有字母是否都为小写
print s.isupper()
print s.lower()
print s.upper() #X123XX 将所有字母转换为大写
ls = ["abc", "xyz", "123"]
print "".join(ls) #将一个列表内的所有字符串连在一起
str = "2018/11/23"
ls = str.split("/") #将字符串以"/"为分隔符拆分为列表
y = int(ls[0]) #将字符串转换为整数
m = int(ls[1])
d = int(ls[2])

字符串的基本操作

#-*- coding utf-8 -*-
s = "中文"
u = s.decode("utf-8") #将字符串以utf-8标准解码为unicode
s2 = u.encode("gbk")  #将unicode以gbk标准编码为字符串 增加"ignore"参数忽略异常的编码
print s  #乱码
print s2 #中文

输出中文字符串

s = "x123xx"  #拿字符串举例 列表相同
print s[0]    #x
print s[-1]   #x 返回倒数第一位置
print s[1:3]  #12 返回[1, 3)位置
print s[1:]   #123xx 返回1到末尾 越界为空
print s[1:-1] #123x 返回[1, 倒数1)
print s[:]    #x123xx 返回所有
print s[::2]  #x2x 从开始到最后 步长为2的返回

序列的基本操作

ls = [0, 1, 2, 3, 4]
ls2 = ls  #ls2引用了ls
del ls2[2] #当删除ls2元素时ls也会被删除
print ls  #[0, 1, 3, 4]
print ls2 #[0, 1, 3, 4]
ls = [0, 1, 2, 3, 4]
ls2 = ls[:] #[:]返回所有元素 相当于拷贝
del ls2[2]
print ls  #[0, 1, 2, 3, 4]
print ls2 #[0, 1, 3, 4]
for i in range(len(ls)): #修改列表内容
    ls[i] = 5
print ls #[5, 5, 5, 5, 5]

python的引用

import os
os.system("ping baidu.com") #调用系统指令 并返回所调用程序返回值
print os.sep #返回系统路径分隔符
print os.linesep #返回系统行终止符
print os.name #打印当前操作系统 W为"nt" L为"posix"
print os.getcwd() #获得当前程序的路径
print os.getenv("path") #获取一个环境变量 如"path" 设置环境变量.putenv(key, val)
print os.listdir(".") #获取一个路径的所有文件和文件夹"."为当前路径
os.remove("C:/a.txt") #删除一个文件
print os.path.split("C:/a.txt") #返回路径的目录"C:/"和文件名"a.txt"
print os.path.exists("C:/a.txt") #检测文件或目录是否存在
print os.path.isfile("C:/a.txt") #检测是否为文件
print os.path.isdir("C:/a.txt") #检测是否为目录

系统模块os的使用

if True :
    pass

pass语句 不做任何操作一般用做占位语句

class Node:
    tot = 0 #所有对象公用变量
    def __init__(self, name): #构造函数
        self.name = name #self代表自身 调用函数时并不传参
        Node.tot += 1 #不支持tot++操作
    def __del__(self): #析构函数
        self.__class__.tot -= 1 #改为先访问类在访问变量 python垃圾回收按照字典序 导致程序结束时类比对象先被回收
        print "del"
    def Display(self):
        print self.name
    def HowMany(self):
        print Node.tot
        
x = Node("X")
x.Display()
x.HowMany()
y = Node("Y")
y.Display()
x.HowMany()
y.HowMany()

类的使用

class A: #超类A
    def __init__(self, name):
        self.name = name
    def DisplayName(self):
        print self.name

class B(A): #子类B继承于超类A
    def __init__(self, name, value):
        self.name = name
        self.value = value
    def DisplayValue(self):
        print self.value

x = B("X", 100)
x.DisplayName()
x.DisplayValue()

类的继承

fp = file("C:/a.txt", "w") #打开文件 w写入r读取a追加写入 open函数??? encoding='utf-8' ??? 
ls = ["1\n", "2\n", "3\n"]
fp.write("hello") #将串写入文件
fp.writelines(ls) #将串或一个串的序列迭代的写入文件 并不增加换行
fp.flush() #将缓冲区的数据写入硬盘
fp.close() #关闭文件

fp = file("C:/a.txt", "r")
print fp.read() #读取整个文件 可以传入去读字节数
fp.seek(0) #移动文件指针到0字节的位置
print fp.readline() #读取一行 len(res) == 0表示读取完
fp.seek(0)
ls = fp.readlines() #将整个文件按行读取进序列 fp.read().splitlines()读取整行并去掉换行符
print ls

文件操作

import cPickle #加载c语言编写的Pickle模块
fp = file("C:/a.txt", "w")
ls = ["abc", "xyz"]
cPickle.dump(ls, fp) #将整个对象完整的存入文件中
fp.close()

fp = file("C:/a.txt", "r")
ls2 = cPickle.load(fp) #将整个对象读出
print ls2 #['abc', 'xyz']
fp.close()

对象的完整存储

#-*- coding utf-8 -*-

def shengxiao(y):
    ls = ["鼠", "牛", "虎", "兔", "龙", "蛇", "马", "羊", "猴", "鸡", "狗", "猪"]
    return "属" + ls[(y - 1972) % 12]

def constellation(m, d):
    ls = ["摩羯座", "水瓶座", "双鱼座", "白羊座", "金牛座", "双子座", "巨蟹座", "狮子座", "处女座", "天秤座", "天蝎座", "射手座", "摩羯座"]
    day = [20, 19, 21, 20, 21, 22, 23, 23, 23, 24, 23, 22]
    if (d < day[m - 1]): #判断是否小于当前星座的日期 小于则返回上一个
        return ls[m - 1]
    else :
        return ls[m]

str = raw_input("请输入生日y.m.d: ".decode("utf-8").encode("gbk"))
ls = str.split(".")
y = int(ls[0])
m = int(ls[1])
d = int(ls[2])
print shengxiao(y).decode("utf-8").encode("gbk")
print constellation(m, d).decode("utf-8").encode("gbk")

输入生日实现函数计算生肖和星座

import random
print random.random()           #输出[0, 1)随机浮点数
print random.randint(1, 9)      #输出[1, 9]随机整数
print random.uniform(1.0, 2.0)  #输出[1.0, 2.0]速记浮点数
print random.choice("ABCD")     #从序列中随机输出一个元素
ls = [1, 2, 2, 4]
print random.sample(ls, 3) #随机选取三个元素 顺序可能会变 不能超出总数

随机模块的使用

try:
    x = input()
except EOFError: #EOF错误会执行本段 如输入CTRL+Z
    print "E"
except: #其他错误会执行本段 如输入未定义变量abc
    print "O"
else: #正常运行执行本段 如输入数值123
    print "Y"

class myex(Exception): #定义一个异常类 需要继承自Exception类或Error类
    def __init__(self, val):
        Exception.__init__(self)
        self.val = val

try:
    x = input()
    if (x < 0): #当输入负数时引发异常
        raise myex(x) #手动引发myex异常
except EOFError:
    print "E"
except myex, m: #当为myex异常时 执行本段 异常变量为m
    print "M", m.val
else:
    print "Y"
import time
try:
    fp = file("C:/a.txt", "r")
    time.sleep(5) #5秒后读取并输入文件的内容
    s = fp.read()
    print s
except:
    print "Error"
finally: #所有情况下都会执行该段 即使在sleep过程中按CTRL+C也会执行
    fp.close()
    print "Close"

异常处理

print "{}+{}={}".format(1, 2, 3) #每个大括号对应后面的一个元素 可以不标号
print "{0:.2}".format(1.0/3) #控制精度
print "{0:<6.2}".format(1.0/3) #左对齐
print "{0:>6.2}".format(1.0/3) #右对齐 
print "{0:^6.2}".format(1.0/3) #中对齐
print "{0:0>3}".format(1) #右对齐不足位置补0

格式化输入输出 也可用作格式化字符串

__str__(self): #在使用print或str()时被调用
__lt__(self): #在使用<时被调用 +、>也有
__getitem__(self, key) #在使用x[key]时被调用
__len__(self) #在使用len()时被调用

python的特殊方法

ls = [2, 4, 3, 1, 5]
ls2 = [i * 2 for i in ls if i % 2 == 0] #将ls中偶数*2后存入ls2
print ls2 #[4, 8]

列表综合

def Max(*item): #参数前带* 传入的不定量参数将被作为一个元组
    res = 0
    for i in item:
        res = max(res, i)
    return res

print Max(2, 3, 1, 5, 4) #5

函数可变数量参数

def mul(n):
    return lambda s: s * n

fun = mul(2)
print fun("hello")
print fun(10)


print map( lambda x: x*x, [y for y in range(10)] ) #输出0到9的平方 ？？？？

lambda函数

exec "print \"hello world\"" #执行字符串或者其他文件中的python语句
print eval("2 * 5") #计算表达式的值

执行其他文件中的python语句

# -*- coding: utf-8 -*-
import sys
reload(sys)
sys.setdefaultencoding("utf8") #设定默认文档编码方式

设定文档的默认编码方式 不用再用decode每次指定

import pyperclip
pyperclip.copy("word") #向剪贴板写入
pyperclip.paste() # 值为剪贴板的内容

剪贴板操作