python基础语法学习笔记

python 笔记

 

变量和类型

    整型 ：二进制-- ob100（十进制4） 八进制-- 0o100(十进制64) 十六进制 --0x100（十进制256）

    浮点型 ： 123.456（数学法）= 1.23456e2（科学计数法）

    字符串型 ： 'hello'  "hello"

    布尔型 ： True False

    复数型 ： 3+4j

 

运算符

[] [:] 下标切片    **指数    ~ 按位取反  + - * /   %取模 //整除  >> <<  & ^按位异或 \|按位或

<= < > >=  == !=  

is  is not 身份运算符

in not  in 成员运算符 

not or and 逻辑运算符

 

类型转换(非函数)

int()：将一个数值或字符串转换成整数，可以指定进制

float()：将一个字符串转换成浮点数

str()：将指定的对象转换成字符串形式，可以指定编码

chr()：将整数转换成该编码对应的字符串（一个字符）

ord()：将字符串（一个字符）转换成对应的编码（整数）

 

分支结构

if语句的使用, 代码块依靠缩进即可

if ... :

    #code

    #code

elif ... :

    #code

    #code

else ... :

    #code

    #code

 

循环结构

1、for-in循环

明确的知道循环执行的次数或者对一个容器进行迭代

for x in range（1,101）:

    #code

 

range(101)可以产生一个0到100的整数序列。

range(1, 100)可以产生一个1到99的整数序列。

range(1, 100, 2)可以产生一个1到99的奇数序列，其中的2是步长，即数值序列的增量。

 

2、while循环

不知道具体循环次数的循环结构

while True:

    #code

    break

 

函数

重复出现和相对独立的功能生成函数

关键字def， return返回一个值

def xxx(arg):

    #code

    #code

    return x

函数参数

可有默认值： def func(n=2)：

可用可变参数： def func(*arg):

 

def add(*args):

    total = 0

    for val in args:

        total += val

    return total

print(add())

print(add(1))

print(add(1, 2))

print(add(1, 2, 3))

print(add(1, 3, 5, 7, 9))

基本输出函数print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    sep=' ' 各个值之间的分隔符
    end='\n' 输出完成后以什么结尾
    file=sys.stdout 输出到标准输出设备
    flush=False 是否立即输出(在写入文件时有用)
 

模块管理函数

 

同名函数：

1、在同一源文件会被后面函数覆盖

2、不同源文件可以导入使用

import module1 as m1

import module2 as m2

m1.foo()

m2.foo()

 

__main__:模块执行开始不执行模块其它代码

 

def main():

    # Todo: Add your code here

    pass

if __name__ == '__main__':

    main()

 

变量作用域

 

def foo():

    b = 'hello'

    def bar():  # Python中可以在函数内部再定义函数

        c = True

        print(a)

        print(b)

        print(c)

    bar()

    # print(c)  # NameError: name 'c' is not defined

if __name__ == '__main__':

    a = 100

    # print(b)  # NameError: name 'b' is not defined

    foo()

 

函数要修改全局变量a的值需加上  global a

 

字符串和常用数据结构

字符串：str1 = 'hello, world!'

列表：[] list1 = [1, 3, 5, 7, 100]  下标[]，切片[:]，排序sorted sort, 

生成式语法生成列表：f = [x for x in range(1, 10)]

                  f = [x + y for x in 'ABCDE' for y in '1234567']

yield关键字将一个普通函数改造成生成器函数

def fib(n):

    a, b = 0, 1

    for _ in range(n):

        a, b = b, a + b

        yield a

def main():

    for val in fib(20):

        print(val)

if __name__ == '__main__':

    main()

元组：（） 与列表类似 元素不可修改 元组在创建时间和占用的空间上面都优于列表

集合：{}  跟数学上的集合是一致的，元素不能重复可以进行交集、并集、差集等运算

字典： 可变容器模型

dict = { key:value,key1:value1} 

print(dict['key'])

 

面向对象编程基础

抽象类

class Student(object)：

    #__init__是一个特殊方法用于在创建对象时进行初始化操作

    #通过这个方法我们可以为学生对象绑定name和age两个属性

    def __init__(self, name, age):

        self.name = name

        self.age = age

    def study(self, course_name):

        print('%s正在学习%s.' % (self.name, course_name))

 

    # PEP 8要求标识符的名字用全小写多个单词用下划线连接

    # 但是部分程序员和公司更倾向于使用驼峰命名法(驼峰标识)

    def watch_movie(self):

        if self.age < 18:

            print('%s只能观看《熊出没》.' % self.name)

        else:

            print('%s正在观看岛国爱情大电影.' % self.name)

def main():

    # 创建学生对象并指定姓名和年龄

    stu1 = Student('骆昊', 38)

    # 给对象发study消息

    stu1.study('Python程序设计')

    # 给对象发watch_av消息

    stu1.watch_movie()

    stu2 = Student('王大锤', 15)

    stu2.study('思想品德')

    stu2.watch_movie()

if __name__ == '__main__':

    main()

 

访问可见性:如果希望属性是私有的，在给属性命名时可以用两个下划线作为开头

class Test:

    def __init__(self, foo):

        self.__foo = foo

    def __bar(self):

        print(self.__foo)

        print('__bar')

def main():

    test = Test('hello')

    # AttributeError: 'Test' object has no attribute '__bar'

    test.__bar()

    # AttributeError: 'Test' object has no attribute '__foo'

    print(test.__foo)

if __name__ == "__main__":

    main()

 

访问可见性:私有属性也可以得到访问，添加更换名字的规则

class Test:

    def __init__(self, foo):

        self.__foo = foo

    def __bar(self):

        print(self.__foo)

        print('__bar')

def main():

    test = Test('hello')

    test._Test__bar() #如此

    print(test._Test__foo)

if __name__ == "__main__":

    main()

 

访问可见性:所以我们并不建议将属性设置为私有的，以单下划线开头来表示属性是受保护的

 

面向对象有三大支柱：封装、继承和多态

封装：隐藏细节提供接口

继承：子类继承父类的变量和方法

多态：重写父类的方法实现不用的功能

 

@property装饰器

以单下划线开头，通过这种方式来暗示属性是受保护的，不建议外界直接访问，

那么如果想访问属性可以通过属性的getter（访问器）和setter（修改器）方法进行对应的操作。

@property包装器来包装getter和setter方法，使得对属性的访问既安全又方便

 

class Person(object):

    def __init__(self, name, age):

        self._name = name

        self._age = age

    # 访问器 - getter方法

    @property

    def name(self):

        return self._name

    # 访问器 - getter方法

    @property

    def age(self):

        return self._age

    # 修改器 - setter方法

    @age.setter

    def age(self, age):

        self._age = age

    def play(self):

        if self._age <= 16:

            print('%s正在玩飞行棋.' % self._name)

        else:

            print('%s正在玩斗地主.' % self._name)

def main():

    person = Person('王大锤', 12)

    person.play()

    person.age = 22

    person.play()

    # person.name = '白元芳'  # AttributeError: can't set attribute

if __name__ == '__main__':

    main()

 

__slots__魔法

在类中定义__slots__变量来进行限定固定的变量

class Person(object):

    # 限定Person对象只能绑定_name, _age和_gender属性

    __slots__ = ('_name', '_age', '_gender')

    def __init__(self, name, age):

        self._name = name

        self._age = age

    @property

    def name(self):

        return self._name

    @property

    def age(self):

        return self._age

    @age.setter

    def age(self, age):

        self._age = age

    def play(self):

        if self._age <= 16:

            print('%s正在玩飞行棋.' % self._name)

        else:

            print('%s正在玩斗地主.' % self._name)

def main():

    person = Person('王大锤', 22)

    person.play()

    person._gender = '男'

    # AttributeError: 'Person' object has no attribute '_is_gay'

    # person._is_gay = True

 

静态方法和类方法

之前，我们在类中定义的方法都是对象方法，也就是说这些方法都是发送给对象的消息。

from math import sqrt

class Triangle(object):

    def __init__(self, a, b, c):

        self._a = a

        self._b = b

        self._c = c

    @staticmethod

    def is_valid(a, b, c):

        return a + b > c and b + c > a and a + c > b

    def perimeter(self):

        return self._a + self._b + self._c

 

    def area(self):

        half = self.perimeter() / 2

        return sqrt(half * (half - self._a) *

                    (half - self._b) * (half - self._c))

def main():

    a, b, c = 3, 4, 5

    # 静态方法和类方法都是通过给类发消息来调用的

    if Triangle.is_valid(a, b, c):

        t = Triangle(a, b, c)

        print(t.perimeter())

        # 也可以通过给类发消息来调用对象方法但是要传入接收消息的对象作为参数

        # print(Triangle.perimeter(t))

        print(t.area())

        # print(Triangle.area(t))

    else:

        print('无法构成三角形.')

 

if __name__ == '__main__':

    main()

 

和静态方法比较类似，Python还可以在类中定义类方法，类方法的第一个参数约定名为cls，

它代表的是当前类相关的信息的对象（类本身也是一个对象，有的地方也称之为类的元数据对象），

通过这个参数我们可以获取和类相关的信息并且可以创建出类的对象

 

from time import time, localtime, sleep

class Clock(object):

    """数字时钟"""

    def __init__(self, hour=0, minute=0, second=0):

        self._hour = hour

        self._minute = minute

        self._second = second

 

    @classmethod

    def now(cls):

        ctime = localtime(time())

        return cls(ctime.tm_hour, ctime.tm_min, ctime.tm_sec)

 

    def run(self):

        """走字"""

        self._second += 1

        if self._second == 60:

            self._second = 0

            self._minute += 1

            if self._minute == 60:

                self._minute = 0

                self._hour += 1

                if self._hour == 24:

                    self._hour = 0

 

    def show(self):

        """显示时间"""

        return '%02d:%02d:%02d' % \

               (self._hour, self._minute, self._second)

 

def main():

    # 通过类方法创建对象并获取系统时间

    clock = Clock.now()

    while True:

        print(clock.show())

        sleep(1)

        clock.run()

if __name__ == '__main__':

    main()

 

继承：

class Person(object):

    """人"""

    def __init__(self, name, age):

        self._name = name

        self._age = age

 

    @property

    def name(self):

        return self._name

    @property

    def age(self):

        return self._age

    @age.setter

    def age(self, age):

        self._age = age

 

    def play(self):

        print('%s正在愉快的玩耍.' % self._name)

    def watch_av(self):

        if self._age >= 18:

            print('%s正在观看爱情动作片.' % self._name)

        else:

            print('%s只能观看《熊出没》.' % self._name)

 

class Student(Person):

    """学生"""

    def __init__(self, name, age, grade):

        super().__init__(name, age)

        self._grade = grade

 

    @property

    def grade(self):

        return self._grade

    @grade.setter

    def grade(self, grade):

        self._grade = grade

 

    def study(self, course):

        print('%s的%s正在学习%s.' % (self._grade, self._name, course))

 

class Teacher(Person):

    """老师"""

    def __init__(self, name, age, title):

        super().__init__(name, age)

        self._title = title

 

    @property

    def title(self):

        return self._title

    @title.setter

    def title(self, title):

        self._title = title

 

    def teach(self, course):

        print('%s%s正在讲%s.' % (self._name, self._title, course))

def main():

    stu = Student('王大锤', 15, '初三')

    stu.study('数学')

    stu.watch_av()

    t = Teacher('骆昊', 38, '砖家')

    t.teach('Python程序设计')

    t.watch_av()

if __name__ == '__main__':

    main()

 

多态：

 

from abc import ABCMeta, abstractmethod

class Pet(object, metaclass=ABCMeta):

    """宠物"""

    def __init__(self, nickname):

        self._nickname = nickname

 

    @abstractmethod

    def make_voice(self):

        """发出声音"""

        pass

class Dog(Pet):

    """狗"""

    def make_voice(self):

        print('%s: 汪汪汪...' % self._nickname)

 

class Cat(Pet):

    """猫"""

    def make_voice(self):

        print('%s: 喵...喵...' % self._nickname)

def main():

    pets = [Dog('旺财'), Cat('凯蒂'), Dog('大黄')]

    for pet in pets:

        pet.make_voice()

if __name__ == '__main__':

    main()