Python学习笔记

输入输出

将数据输出到文件中：（注意点）

1. 所指定的盘存在
2. 使用file=fp

fp=open('D:/text.txt','a+')
print('hellworld',file=fp)
fp.close()

一、字符串

• title（）以首字母大写的方式显示每个字母
  +拼接字符串
• strip（）删除空白字符
• 我们前面调用print时，会自动打印一个换行符。有时，我们不想换行，不想自动添加换行
  符。我们可以自己通过参数end =“任意字符串”。实现末尾添加任何内容:
• 各种类型可直接转换成字符

>>>int ("234")234
>>> float ("3.14")3.14
>>>str (5.20)5.2’
str (314)314'
>>>str (3.14e2)314.0’
>>> str (True)
>>>‘True'

• 字符串的本质就是字符序列，我们可以通过在字符串后面添加，在[里面指定偏移量，可以提取该位置的单个字符。
  正向搜索：最左侧第一个字符，偏移量是0，第二个偏移量是1，以此类推。直到len(str)-1为止。
  反向搜索︰最右侧第一个字符，偏移量是-1，倒数第二个偏移量是-2,以此类推，直到-len(str)为止。

>>> "abc"+" def"
'abcdef'
>>> a = ["sxt","sxt100", "sxt200"]
>>>"*".join(a)
'sxt*sxt100*sxt200’
>>>"".join(a)
'sxtsxt100sxt200’

可变字符串：

>>> s = "hello,sxt'
>>>> import io
>>>sio = io.StringIO(s)
>>>> sio
<io.String1O object at ox02CF27BO>
>>> sio.getvalue()
' hello,sxt'
>>>sio.seek (7)
7
>>>sio.write("g")
1
>>> sio.getvalie()
' hello,gxt'

二、列表

• 使用list)可以将任何可迭代的数据转化成列表

>>>a_=_[20,30,40,"gaoqi“] 
>>>a[0]
20
>>> a[3]
’gaoqi'
a = [ ]
>>> a.append(20)
>>>a
[20]
>>> a = list()
>>>a
[ ]
>>>a = list("gaoqi")
['g', 'a', 'o', 'q', 'i']
>>> range(10)
range(0,10)
>>>a = range(10)
>>> type(a)
<class 'range’>
>>> list(a)
[0,1,2,3,4,5,6,7,8,9]
>>> list(range(10) )
[0,1,2,3,4,5,6,7,8,9]

将索引值指定为-1,返回最后一个元素
del 删除
remove（）知道删除元素的值

• sort（）永久性排序
  sorted（）建立副本排序
• range（）生成数字列表
• 增加元素：一个用append，合并列表用extend
• 内置函数reversed()也支持进行逆序排列，与列表对象reverse()方法不同的是，内置函数reversed()不对原列表做任何修改，只是返回一个逆序排列的迭代器对象。

>>> a = [20,10,30,40]
>>> c = reversed(a)
>>>d
<list_reverseiterator object at Ox0000000002BCCEB8>
>>> list(c)
[40,30,10,20]
>>> list(c)

三、元组

• 创建：通过（）创建，小括号可以省略，当只有一个元素，需要加逗号；通过tuple()创建元组，把其他对象转换为元组
• 总结∶
  tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组。
  list()可以接收元组、字符串、其他序列类型、迭代器等生成列表。
• 元组的元素不能修改
• zip(列表1，列表2，…)将多个列表对应位置的元素组合成为元组，并返回这个zip对象。

四、字典

• ().key，().value，().item
• 我们可以通过0、dict()来创建字典对象。

a = {'name":'gaoqi ;'age":18,'job:'programmer'}
b = dict(name='gaoqi",age=18,job='programmer')
a = dict([("name","gaoqi").("age",18)])

通过zip()创建字典对象

k = ['name'; 'age',"job']
v = ['gaoqi',18,'techer']
d = dict(zip(k,v))

>>> d
{'name': 'gaoqi', 'age': 18, 'job': 'techer'}

通过fromkeys创建值为空的字典

a = dict.fromkeys(['name';'age','job'])

• 通过get()方法获得“值”。推荐使用。优点是∶指定键不存在，返回None ; 也可以设定指定键不存在时默认返回的对象。推荐使用get()获取“值对象”。

>>> a.get('name')
'gaoqi'
>>> a.get('sex')
>>> a.get('sex','一个男人')
'一个男人'

• 字典中元素的删除，可以使用del()方法;或者clear()删除所有键值对;pop()删除指定键值对，并返回对应的“值对象”;

>>>a = {'name':'gaoqi" ,'age:18,'job:'programmer'}
>>>> del(a['name'])
>>> a
{'age': 18, 'job': 'programmer'}>>>b = a.pop('age')
>>>b
18

• sorted（ditcA.items(),key=lamda d:d[0]) 其中d[0]，d[1]分别表示按键和内容排序
• popitem():随机删除和返回该键值对。字典是“无序可变序列”，因此没有第一个元素、最后一个元素的概念;popitem弹出随机的项，因为字典并没有"最后的元素"或者其他有关顺序的概念。若想一个接一个地移除并处理项，这个方法就非常有效(因为不用首先获取键的列表)。
• while、for循环可以附带一个else语句(可选)。如果for、while语句没有被break语句结束，则会执行else子句，否则不执行。语法格式如下∶

while 条件表达式: 
	循环体 
else : 
	语句块 
或者:
for 变量 in 可迭代对象︰ 
	循环体 
else : 
	语句块

四、函数

可选参数接受的是元组
关键字参数接受的是字典
format 格式化输出
通过global可实现函数内部对全局变量的修改
remove() 括号内为要删除的元素，如果多个元素一样，默认删除第一个

创建匿名函数：lambda 参数1 参数2 参数3：执行代码

数学运算：
abs（）取绝对值
round（）取浮点数的近似值
pow（）求次方
eval（）动态执行表达式

强制类型转换：
chr（）数字转字符
bin（）转成二进制
hex（）转成十进制
list（）元组转换成列表

set（）清除重复，无序且不重复的集合

五、类

• 我们把对象比作一个“饼干”，类就是制造这个饼干的“模具”。我们通过类定义数据类型的属性（数据）和方法(行为）,也就是说，“类将行为和状态打包在一起”。
  
  对象是类的具体实体，一般称为“类的实例”。类看做“饼干模具”，对象就是根据这个“模具”制造出的“饼干”。
  从一个类创建对象时，每个对象会共享这个类的行为（类中定义的方法），但会有自己的属性值（不共享状态)。更具体一点:“方法代码是共享的，属性数据不共享”。
  

• 类属性相当于共有的，修改类属性的值，随后创建对象的值也会改变，通过_init_() 定义属性的值，对属性值进行修改，只会对当前的对象生效
  类方法和静态方法中，不能调用实例变量、实例方法
  

从方法定义的形式可以看出：

1.类方法的第一个参数是类对象cls，进而去引用类对象的属性和方法，修改类属性的值必须通过类对象 @classmethon
属性前面加两个__,就变成私有属性，类内部可以访问私有属性(方法)，类外部不能直接访问私有属性(方法)
类外部可以通过“类名_私有属性(方法)名”访问私有属性(方法)
2.实例方法的第一个参数是self，进而引用类属性和实例属性，若存在相同名称的类属性和实例属性，实例属性的优先级最高
3.静态方法不需要定义额外的参数，若要引用属性，可以通过类对象和实例对象去引用 @staticmethon

• 在其他语言中，可以定义多个重名的方法，只要保证方法签名唯一即可。方法签名包含3个部分︰方法名、参数数量、参数类型。
  Python中，方法的的参数没有类型(调用时确定参数的类型），参数的数量也可以由可变参数控制。因此，Python 中是没有方法的重载的。定义一个方法即可有多种调用方式，相当于实现了其他语言中的方法的重载。如果我们在类体中定义了多个重名的方法，只有最后一个方法有效。
  建议:不要使用重名的方法! Python中方法没有重载。

• @property可以将一个方法的调用方式变成"属性调用”。

class Employee:
    def _init_(self, name, salary):
        self._name = name
        self._salary = salary

    @property
    def salary(self) :
        return self._salary

    @salary.setter
    def salary(self, salary) :
        if 1000<salary<50000:
            self._salary = salary
        else:
            print("录入错误!薪水在1000—-50000这个范围")

emp1 = Employee("高淇",30000)
print(emp1.salary)
emp1.salary = 2000
print (emp1.salary)

继承

Python支持多重继承，一个子类可以继承多个父类。继承的语法格式如下︰

class子类类名(父类1[，父类2，.]):
	类体

如果在类定义中没有指定父类，则默认父类是object类。也就是说，object 是所有类的父类，里面定义了一些所有类共有的默认实现，比如:new()。
定义子类时，必须在其构造函数中调用父类的构造函数。调用格式如下:

父类名._init__(self，参数列表)

class Person:
    def __init__ (self, name, age) :
        self. name = name
        self._age = age#私有属性
        self.__age = age  # 私有属性

    def say_age (self) :
        print("年龄,年龄,我也不知道")

class student(Person):
    def __init__ (self, name,age,score):
        Person.__init__(self,name,age) #必须显式的调用父类初始化方法，不然解释器不会去调用
        self.score = score

#Student-->Person-->object类
print(student.mro())
s = student("高淇",18,60)
s. say_age()
print(s.name)
#print (s.age)
#dir 打印属性名

print(dir(s))#  '_age', 'name', 'say_age', 'score'
print(s._age)
print(s._Person__age)

1．成员继承:子类继承了父类除构造方法之外的所有成员。
2．方法重写∶子类可以重新定义父类中的方法，这样就会覆盖父类的方法，也称为“重写”
3．Python支持多重继承，一个子类可以有多个“直接父类”。这样，就具备了“多个父类”的特点。但是由于，这样会被“类的整体层次”搞的异常复杂，尽量避免使用。如果父类中有相同名字的方法，在子类没有指定父类名时，解释器将“从左向右”按顺序搜索。

class Person:
    def __init__ (self, name, age) :
        self. name = name
        self._age = age#私有属性
        self.__age = age  # 私有属性

    def say_age (self) :
        print("年龄,年龄,我也不知道")

    def say_introduce(self):
        print("我的名字是{0}".format(self.name))

class student(Person):
    def __init__ (self, name,age,score):
        Person.__init__(self,name,age) #必须显式的调用父类初始化方法，不然解释器不会去调用
        self.score = score

    def say_intrcduce(self) :
        #重写了父类的方法
        print("报告老师,我的名字是:{o}".format(self.name))


s = student("高淇",18,80)
s. say_age()
s. say_introduce()

通过类的方法mro)或者类的属性_mro_可以输出这个类的继承层次结构

class A:pass
class B(A):pass
class C(B):pass
print(C.mro())

在子类中，如果想要获得父类的方法时，我们可以通过super()来做。super()代表父类的定义，不是父类对象。

class A:
    def say(self):
        print(" A:" , self)

class B(A):
    def say(self):
        # A.say(self)
        super().say()
        print("B:",self)

B().say ()

多态

是指同一个方法调用由于对象不同可能会产生不同的行为。

关于多态要注意以下2点:
1.多态是方法的多态，属性没有多态。
2.多态的存在有2个必要条件∶继承、方法重写。

class Man:
    def eat(self):
        print("饿了，吃饭啦! ")

class Chinese(Man):
    def eat(self):
        print("中国人用筷子吃饭")

class English (Man):
    def eat(self):
        print("英国人用叉子吃饭")

class Indian (Man):
    def eat(self):
        print("印度人用右手吃饭")

def manEat(m):
    if isinstance(m, Man):
        m.eat()
    else:
        print("不能吃饭")

manEat (Chinese())
manEat(English())

组合

class A2:
    def say_a2(self):
        print(" a2, a2, a2")

class B2:
    def _init_(self, a):
        self.a = a

a2 =A2()
b2 = B2(a2)
b2.a2.say_a2()