Python

输入输出：

输入
    raw_input()
    raw_input("")//含有提示内容
输出
    print()

原码、反码、补码

规则
    正数 原码 = 反码 + 补码
    负数 反码 = 符号位不变，其他位取反码
    补码 = 反码 + 1

字符串的使用：

<1> find

  查找字符串中是否含有一段字符,未找到则返回-1
  str.find("")

<2> index

    查找字符串中是否含有一段字符,未找到则返回异常
    str.index("")
    str.index("",start,end)参数一：查找的字符，参数二：下标起始位置，参数三：下标结束位置

<3> count

    统计个数(即可以统计单个字符也可以统计一段字符串)
    str.count("")
    str.count("",start,end)参数一：统计的字符，参数二：下标起始位置，参数三：下标结束位置

<4> len

    返回字符串长度
    len(str)

<5> replace

    替换
    str.replace("","")参数一：原字符，参数二：替换的字符

<6> split

        分隔符切片
        str.split(" "){根据输入内容切割}
        str.split(" ",2)参数一：切割的字符 参数二：总共切割后的份数

<7> capitalize

        把字符串的第一个字符大写
        str.capitalize()

<8> startswith

        判断是否以什么开头
        返回True Or False
        str.startswith("")

<9> endswith

        判断以什么结尾
        返回True Or False
        str.endswith("")

<10> lower

        把字符串中的大写字母转换成小写字母
        str.lower()

<11> upper

        把字符串中的小写字母转换成大写字母
        str.upper()

<12> ljust

        返回一个原字符串左对齐并用空格填充长度至width
        str.ljust(width)

<13> rjust

        返回一个原字符串右对齐并用空格填充长度至width                       str.rjust(width)

<14> center

        返回一个原字符串居中对齐并用空格填充长度至width                      str.center(width)

<15> lstrip

        删除左边的空格
        str.lstrip()

<16> rstrip

        删除右边的空格
        str.rstrip()

<17> rfind

        类似于find，只不过从右边开始查找

<18> rindex

        类似于index（），从右边开始

<19> partition

        把str以str2分隔成三部分，str2前，str2，str2后
        str.partition(str2)

<20> rpartition

        和partition()类似，从右边开始

<21> splitlines

        按照行分隔（消除换行符）
        str.splitlines()

<22> isdigit

        如果str值包含数字则返回True否则返回False
        str.isdigit()

<23> isalpha

        如果str所有字符都是字母则返回True否则返回False
        str.isalpha()

<24> isalnum

        如果str中是数字或字符返回True否则返回False
        str.isalnum()

<25> isspace

        如果str中只包含空格则返回True否则返回False
        str.isspace()

<26> isupper

        判断所有字符是纯大写返回True否则返回False
        str.isupper()

<27> islower

        判断所有字符是纯小写返回True否则返回False
        str.islower()

<28> join

        str中每个字符后面插入str2，构造出一个新的字符串
        str.join(str2)
        例子：
            str = " "
            li = ['ni','hao','me']
            print(str.join(li))
            'ni hao me'
            str2 = "_"
            print(str2.join(li))
            ni_hao_me

列表

一、使用[ ] 括起来中间用逗号隔开

ls = ['asd','wqe','zxc']

二、列表中可以存储不同类型的数据

ls = ['asd','qwe','zxc',123,456,True]

三、遍历列表内容

name = ['qwe','asd','zxc',wer',sdf',xcv]
nub = 0 
length = len(name)
whiel nub < length:
    print('name[%d]=%s'%(nub,name[nub]))
    nub  += 1

name = ['qwe','asd','zxc',wer',sdf',xcv]
for j in name:
    print("j=%s"%j)

四、列表常用操作

append

            添加
lb = ['123','qwe','asd','zxc']
lb.append("wer")

更改

            更改
lb = ['123','qwe','asd','zxc']
lb[0] = '456'

if ….in

            判断列表中是否含有某个值
lb = ['123','qwe','asd','zxc']
if '123' in lb:
    print("含有123")

删除

li=['asd','qwe','zxc''wer','sdf','xcv']

del:根据下表进行删除

del li[0]

pop：删除最后一个元素

li.pop()

remove：根据元素的值进行删除

li.remove('asd')

字典

一、以{ }括起来（以键值对的方式）

​ 可以存储不同类型的数据

d = {"name":"zhangsan","addr":"shandong","age":18}

​ 取值

print(d['name'])

二、常见操作

1、修改

  d = {"name":"zhangsan","addr":"shandong","age":18}
  d['name'] = "lisi"

2、添加

  d = {"name":"zhangsan","addr":"shandong","age":18}
  d['hh']=10

3、删除

1)del

删除单个元素

>>>d = {"name":"zhangsan","addr":"shandong","age":18}
  >>>del d['name']

删除字典
del d

2)clear() 清空字典内的内容

    >>>d = {"name":"zhangsan","addr":"shandong","age":18}
    >>>d.clear()

4、len()

返回键值对的个数
>>>d = {"name":"zhangsan","addr":"shandong","age":18}
>>>len(d)

5、keys()

返回字典所有的可以键
d.keys()

6、values()

返回字典所有的可以值
d.values()

7、items()

返回一个包含所有（键值对）元祖的列表
d.items()
[('name','zhangsan'),('addr','shandong'),('age',18)]

8、has_key

如果字典里有key则返回True否则返回False
d.has_key('key')

元组

一、以（）括起来

typle = ('hello',100,2,3)
取值
typle[0]---->'hello'

二、常用操作

1、修改(Python中不允许修改)

tuple[2]=188
TypeError:

2、合并元组

tup1=('hellp',100)
tup2=(1,2,3)
tup3 = tup1+tup2
tup3---->('hellp',100,1,2,3)

3、删除元素(元组中不允许删除其中的值，但可以使用del删除整个元组)

del tuple

4、元组运算符

Python表达式	结果	描述
len(1,2,3)	3	计算元组的个数
(1,2,3)+(4,5,6)	(1,2,3,4,5,6)	连接
[‘Hi!’] * 4	[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’]	复制
3 in (1,2,3)	True	元组是否存在
for x in (1,2,3):print x	1 2 3	迭代

5、元组索引，截取

L=(‘span’,’Spam’,SPAM!)

Python表达式	结果	描述
L[2]	‘SPAM!’	读取第三个元素
L[-2]	‘Spam’	读取倒数第二个元素
L[1:]	(‘Spam’,SPAM!)	截取元素

6、元组内置函数

序号	方法	描述
1	cmp(tuple1,tuple2)	比较两个元组元素
2	len(tuple)	计算元组个数
3	max(tupe)	返回元组中最大的
4	min(tupe)	返回元组中最小的
5	tuple(seq)	将列表转换成元组

函数

一、定义

def xx():#不带参数
Or
def xx(xx):#带参数

例：
    def add(a,b):
        c=a+b
        print("%d+%d=%d"%(a,b,c))
    add(100,200)

二、缺省参数(提供一个默认参数)

def text(name,age=18):
    print("name=%s,age=%s"%(name,age))
text('zhangsan')--->name=zhangsan,age=18
text('zhangsan',16)--->name=zhangsan,age=16
另外一种输入方法
    text(age=16,name='zhangsan')--->name=zhangsan,age=16

三、不定长参数

def text(*name):
    pass

全局变量与局部变量

全局变量是在函数外面定义的，局部变量是在函数内部定义的

g_a = 200
def text():
    g_a = 100
    print("text方法的a=%d"%g_a)
def text2():
    print("text2方法的a=%d"%g_a)


---->text方法的a=100
     text2方法的a=200
如果一个函数中有与全局变量同名的局部变量调用的是局部变量（该局部变量不会修改全局变量中的值）

g_a = 200
def text():
    global g_a
    g_a = 100
    print("text方法a=%d"%g_a)
def text2():
    print("text2方法的a=%d"%g_a) ---->text方法的a=100
    text2方法的a=100
如果用global 标识了一个全局变量那么在局部变量中赋值时将会修改全局变量的值

匿名函数

lambda
lambda 参数：运算
执行函数并返回结果
例子：
    lam = lambda a,b:a+b
    result = lam(11,22)
    print('result=%d'%result)---->33

文件操作

<1>打开文件

创建一个新文件，文件名为test
open时 当前路径可省略 其他使用绝对路径
w------>用于写入，如果文件已存在则覆盖，文件不存在则创建
r------>用于只读。文件的指针放在开头
a------>用于追加。文件不存在则创建
f = open('test.txt','w')

<2>关闭文件

关闭这个文件
f.close()

<3>文件的写入–write

f = open('test.txt','w')
f.write('hello')
f.close()

<4>文件的读取—read

f = open('test.txt','r')
content = f.read()
print(content)
f.close()

1、readlines（）

与read 的区别：readlines 返回类型为list
f = open('test.txt','r')
content = f.readlines()
for temp in content:
    print(temp)
f.close()

2、readline()

与readlines（）的区别： readlines（）方法读取的是所有信息，存到一个集合中
而readline（）方法是指读取一行
f = open('test.txt','r')
content = f.readline()
while True:
    if len(content) != 0:
        print(content)
    else:
        break

f = open('test.txt','r')
content = f.readline()
while len(content)>0:
    print(content)
    content = f.readline()

<5>文件拷贝

from pip._vendor.distlib.compat import raw_input

#1.提示用户输入拷贝的文件名字
oldFileName = raw_input('请输入要拷贝的文件名字：')

#2.打开文件

oldFile = open(oldFileName,'r')

#3.读取这个文件的数据 因为使用read 或者readlines 这两个函数，
# 他们一次性把文件中的所有内容都读取到内存中，
# 可能因为文件太大，导致内存不足的情况，所以可以使用readline方式

#4.组织文件名字
num = oldFileName.rfind('.')

newFileName = oldFileName[0:num]+'[复件]'+oldFileName[num:]

#5.新建一个文件
newFile = open(newFileName,'w')

#读取一行数据
content = oldFile.readline()
while len(content)>0:
    newFile.write(content)
    content = oldFile.readline()

oldFile.close()
newFile.close()

<6>文件的定位读写

seek(offset，from)——-偏移多少位

offset：偏移量

from：方向

​ 0：表示文件开头

​ 1：表示当前位置

​ 2：标识文件末尾

tell（）—-返回当前文件读写位置

f = open('123.txt','rb')
f.read(2)
f.read(2)
f.read(2)
print(f.tell())
f.seek(-2,2)
print(f.tell())
f.close()

*注意：当使用seek（-2，2）时

需要在 打开文件方式时以‘rb’方式打开 否则会报io.UnsupportedOperation: can’t do nonzero end-relative seeks错误

原因是因为以‘r’方式打开文件 只允许从文件开始计算相对位置，从文件尾计算时会引发异常

<7>文件重命名

import os
os.rename(oldName,newName)

<8>文件删除

import os
os.remove('123[复件].txt')

<9>文件夹的操作

1、文件夹的创建

os.mkdir('文件名')
**这个文件名即可以是相对路径也可以是绝对路径

2、获取当前路径

os.getcwd()

3、改变默认路径

os.chdir('...'/)

4、获取目录列表

os.listdir('...')
同时遍历隐藏文件

<1>遍历文件夹内容

movieNames=os.listdir('baike_Py')
for temp in movieNames:
    print(temp)

5、删除文件夹

os.rmdir('...')
**只能删除空的文件夹

异常

try:

except:
    print('error')
else:
    print("我是else")
finally:
    print(“我是finally”)

try 将可能出错的代码放入 如果有有错误则执行except 否则执行else
最终都需要执行finally

python的try语句有两种风格

一：种是处理异常（try/except/else）

二：种是无论是否发生异常都将执行最后的代码（try/finally）



try/except/else风格

try:

    <语句> #运行别的代码

except <名字>： 

    <语句> #如果在try部份引发了'name'异常

except <名字>，<数据>:

    <语句> #如果引发了'name'异常，获得附加的数据

else:

    <语句> #如果没有异常发生

try的工作原理是，当开始一个try语句后，python就在当前程序的上下文中作标记，这样当异常出现时就可以回到这里，try子句先执行，接下来会发生什么依赖于执行时是否出现异常。

1、如果当try后的语句执行时发生异常，python就跳回到try并执行第一个匹配该异常的except子句，异常处理完毕，控制流就通过整个try语句（除非在处理异常时又引发新的异常）。

2、如果在try后的语句里发生了异常，却没有匹配的except子句，异常将被递交到上层的try，或者到程序的最上层（这样将结束程序，并打印缺省的出错信息）。

3、如果在try子句执行时没有发生异常，python将执行else语句后的语句（如果有else的话），然后控制流通过整个try语句。





try/finally风格

try:

    <语句>

finally:

    <语句> #退出try时总会执行



python总会执行finally子句，无论try子句执行时是否发一异常。

1、如果没有发生异常，python运行try子句，然后是finally子句，然后继续。

2、如果在try子句发生了异常，python就会回来执行finally子句，然后把异常递交给上层try，控制流不会通过整个try语句。

当你想无论是否发生异常都确保执行某些代码时，try/finally是有用的。



这个在打开文件的时候有用 finally总是在最后close()文件



try语句子句形式表

except: 捕获所有异常

except name: 只捕获特定的异常

except name,value: 捕获异常和它的附加数据（将异常的信息保存到value，）

except (name1,name2): 捕获任何列出的异常

else: 如果没有异常

finally: 总是执行



>>> try:

   f = open('file.txt')

except IOError, e:

   print e

else:

        print 'wrong'





[Errno 2] No such file or directory: 'file.txt'



最新的python版本 支持try/except/finally



try: 1:如果x没有异常，执行z,i

    x 2:如果x有异常， 一：如果except捕捉到异常则执行y,i

except(name): 二：没捕捉到，执行i,然后返回内置异常处理 

    y

else:

    z

finally:

    i

类

class 类名:
    属性
    方法

class Dog:
    color = '白色'
    sex = '公'

    #方法
    def eat(self):
        print('狗吃东西')
    def run(self):
        print('狗在跑路')

self——-调用者本身

class Animal:
    def setName(self,name):
        self.name = name
    def printName(self):
        print('名字为：'self.name)
def myPrint(animalName):
    animalName.printName()

dog1 = Animal()
dog1.setName('西西')
myPrint(dog1)

dog2 = Animal()
dog2.setName('北北')
myPrint(dog2)

构造方法——当创建对象时执行

def __init__(self):

初始化数据

析构方法——当对象消除时执行

def __del__(self):

释放空间

删除一个对象

del 对象名

继承

class Cat:
    color = 'black'
    legs = 4
    weight =6

    def miaomiao(self):
        print('猫在叫')
    def catch(self):
        print('抓老鼠')

class Bosi(Cat):
    def maimeng(self):
        print("波斯猫卖萌")
    def miaomiao(self):
        print("波斯猫在叫")

bosi = Bosi()
bosi.miaomiao()
bosi.catch()
bosi.maimeng()

多继承

class A:
    def text(self):
        print('-'*5+'A')

    def text1(self):
        print('-' * 5 + 'A2')

class B:
    def text(self):
        print('-'*5+'B')

    def text2(self):
        print('-' * 5 + 'B2')

class C(B,A):
    def text(self):
        print('-'*5+'C')

c = C()
c.text1()   -----A2
c.text2()   -----B2
c.text()    -----C

注意 如果在多继承中 A和B类中有相同的方法则会执行 继承时写在前面的 如果C类中也有和A,B类相同的方法则会执行自己的方法

重写

子类的方法名与父类的方法名相同

执行时执行子类方法