Python基础（粗略整理，笔者会持续更新）

Python基础（粗略整理，笔者会持续更新）

输出函数print

print(520) # 可以输出数字
print(98.5) 

print("String")
str4_ = "We all know that 'A' and 'B' are two capital letters." # 输出字符串，没毛病，单双都可
print(3+1) # 输出带运算符表达式

#可以输入到指定的文件
fp = open('S:/test.txt','a+') # 注意不是反斜杠。这个文件操作真的简单 a+ 以为不存在则创建，存在则追加
print("hello world",file=fp)# 注意要加file = *
fp.close

#不进行换行输出，写在一行？？？

转义字符

• \t 制表符以四个字符为单位，可以理解为补齐空格，所以才能制表嘛。会出现1、2、3、4=个空格，即是否重开制表位问题。
• 原字符 在字符串前加个r或R

r"Hello\nworld" #字符串最后一个字符不能是反斜线

标识符和保留字

保留字查看的方法：

import keyword
print（keyword.kwlist）

标识符规则基本一致

变量的定义和使用

• 变量的定义：

  变量名 = *

  name = “miao”
  

• 变量的组成：
  标识，类型和值分别可以通过内置函数id(),type(),以及其本身获得
  所以都是引用变量呢

• 多次复制之后，变量名会指向新的空间。 没有被指向的会成为垃圾

数据类型

• 不带小数的都叫int

• 带小数的都叫float

  浮点数的计算输出因为存储方式问题会存在结果容易出问题的问题。

  用decimal（）解决。

• True和Fale分别是0 1

• 字符串，不解释

  称为不可变的字符序列

  ‘单引号’ “双引号” “”"“三引号”"" 其中单双必须在一行，三可以随意

print(str,type(str)) # 直接逗号分隔。。。

类型转换

str( )函数

懂得都懂，可以讲括号里面的转成字符串

int( )

float( )

不多BB

input( )函数

enter = input('输入提示')

类型转换

int(enter)

基本运算

算术运算符

• 除法运算 /

  1/2 = 0.5

• 整除运算

  11//2 = 5

• 幂运算 **

  2**2 = 4

• 一正一负的整除和取余

  一正一负的整除向下取整

  9//-4 = -3

  余数 = 被除数-出书*商

  9%-4 = -3 -9%4 = 3

赋值运算符

• 运算顺序从右到左
• 支持链式赋值

a=b=c=20 # 内存地址相同，懂得都懂

• 参数赋值

a+=30 #等一系列操作

• 系列解包赋值

a,b,c = 10,20,30

比较运算符

• 比较运算的结果时Bool类型
• == 比较的是对象的值
• is运算符比较的是对象的标识（地址，id）is not 不解释

Bool运算符

• and -> &&
• or ||
• not !
• in 在不在,可以~ 同样的还有 not in

s = "hello world"
"w" in s 

程序的bool值

内置函数bool()

• 布尔值位False：False、数值（）、None、空字符串、空列表、空元组、空字典、空集合

程序的组织结构

顺序、循环、选择

顺序结构

从上到下，依次执行

选择结构

根据bool值判断语句是否执行

• 单分支结构：

  if num>=n : # (num>=n) 这么些也是可以的
      print("我说可以~")
  

• 双分支结构：

if(num>=n)

• 多分支结构：

if num>n:
    print("ky")
elif num==n:
	print("ky")
else:
    printf("gun")
    

• 分支结构之间允许出现嵌套

• if else 简写，类似于三目运算符

  x if condition else y

pass语句

• 语句什么都不做，只是一个占位符，用在语法上需要语句的地方

if(a>b):
    pass # 用于构建语句

循环结构

range()函数

• 用于生成一个整数序列
• 创建方式：

# 一参,范围，但是不包括右区间点
r = rang(10) # 返回结果是一个迭代器对象，默认从0开始，默认相差1
list(r) # list 生成一个列表，用于存储迭代器对象序列

# 二参，指定了起始值
range(1,10)

# 三参，起始值，结束值，步长
range(1,10,2)

• 可以使用in和not in来进行bool运算
• 对象只储存三个值，占内存空间较小，很灵活，再用到range时才会产生相关的序列

while

while condition:

​ sentence

• 初始化变量
• 条件判断
• 执行语句
• 改变变量

for-in

for var in iterableOBJ:

​ sentence

• 通常用序列和字符串去作为可迭代对象

• 用不到变量的话可以用 _ 替代

for _ in range(5):
    print("wo tu le ")

break 和 continue

• 直接写就完了

break
continue

else 在循环中

• else写在循环之后，如果循环执行过程中没有遇到break那么之心完毕之后会执行else

for item in range(5):
    print("Hello!")
    if(item==5):
        break
else:
    print("word")

列表—数组

• id,type,value

列表的创建

• 方括号

  list = ["hello","world"]
  

• 使用内置函数list

  list = list(["hello","world",321]) # 混合类型。。。
  

列表的特点

• 列表元素有序排列
• 索引银蛇第一个数据
• 列表可以存放重复数据
• 任意数据类型混合存储
• 根据需要动态的分配和回收内存

list的元素获取

获取单个元素

• 通过index( )函数

  list.index("str") # 返回第一个匹配的索引，不存在则抛出异常
  list("str",star,end) # 返回区间内的索引
  

• 通过索引去获得元素

  list[2] # 正向获取 0~n-1 ,n为元素个数
  list[-3] # 逆向获取 -n~-1
  

获取多个元素

• 切片操作，同样不包括stop

  • list_name[star:stop:step]

  • step默认为1，可简写为[star:stop]

  • step为正数，从star开始往后计算切片；为负数则从star往前挤蒜切片

  • step，步长，1无间隔，2间隔1……

遍历

for-in,天生的迭代器

列表元素的添加

• append( )，追加

• extend( ),在列表的末尾至少添加一个元素，对于列表的操作

• instet( )，任意位置插入

• 切片，任意位置至少添加一个元素

  list[1:] = list3 # 从第一个元素开始切掉后面的，把list3接到后面
  

列表元素的删除

• remove( )

  • 一次删除一个元素
  • 重复元素只删除第一个
  • 不存在元素抛出异常

• pop( )

  • 删除一个指定索引的元素
  • 不存在抛出异常
  • 没有指定索引删除最后一个，有出栈那味儿了

• 切片

  • 一次至少删除一个呗

• clear( )

  • 清空表

• del

  • 删除表

    del list # 删除对象
    

列表元素的修改

• 为指定的元素赋予一个新值
• 为指定切片赋予一个新值，切下来一块，补充上去，不在乎长度，自动扩充的

列表的排序操作

• sort( )方法

  • 默认进行升序排序，内部有参数reserve=True可以进行降序

• 内置函数sorted

  • 会产生一个新的列表，需要一个变量去接一下

  列表生成式

• list = [i for i range (star,stop)]

  • i 的位置是表示列表元素的表达式

字典

• Python内置的数据结构之一，与列表一样是一个可变序列
• 以键值对的方式存储数据，字典是一个无需的序列。 类似于Map
• 地点的实现原理类似于hashMap，由key到value的处理。经过hash函数，所以在内存上存储时无序的。

字典的创建

• 使用花括号

  score = {"zhangsan": 100 , "lisi": 98, "wangwu": 45}
  

• 使用内置函数dict( )

  dict(name = "jack" , age = 20) # 注意，这里的键没有加引号
  

字典元素的获取

• 用[ ]来获取

  score["zhangsan"] # 如果字典中不存在对应的值则抛出keyError异常
  

• 用get( )

  score.get("zhangsan") # 如果字典中不存在key，返回None
  score.get("zhaoliu",bucunzaide) # 可以通过参数设置默认的value，以便指定key不存在时的返回值
  

字典元素的删除

del score["zhangsan"]
score.clear() # 清空整个字典

字典元素的新增

score["jack"] = 90 # 类似的还可以用来修改

获取字典视图的三个方法

• keys( )获取字典中所有的key
• values( )获取字典中所有的valus
• items( ) 获取字典中所有的K V对

字典元素的遍历

for item in score:
    print(score[item]) # item是Key

字典的特点

• 字典中的所有元素都是一个key-value对，key不允许重复，value可以重复
• 字典中的元素是无序的
• 字典中的key’必须是不可变对象
• 字典可以根据需求自动的伸缩
• 字典会浪费较大的内存，是一种空间换时间的数据结构

字典生成式

• 内置函数 zip()

  list = zip(item,price) # 可迭代对象作为参数
  print(list)
  

元组和集合

元组

• Python的内置数据结构之以，是一个不可变序列

不可变序列与可变序列

• 不可变序列：包括字符串和元组，没有 增 删 改 的操作
• 可变序列：列表、字典和集合，可以对序列执行 增 删 改 操作，对象的地址不发生改变

元组的创建

• 小括号

  t = ("PYTHON","hello",90) t = ("PYTHON",)
  

• 内置函数tuple( )

  t = tuple(("PYTHON","hello",90))
  

为什么设计这个东西？

• 在多任务环境下，同时操作对象时不需要加锁（根本改不了），使用在程序中尽量使用不可变序列
• 可以动对象的值但是不能动地址

集合

• 与列表和字典一样属于可变类型的序列
• 集合时没有value的字典，数据结构同样是hash表

集合的创建

• 大括号

  s = {"Python","hello",90}
  

• 使用内置函数set( )

  s = set(range(5))
  s = set({"Python","hello",90})# 括号里面放可迭代的对象
  

集合元素的相关操作

• 新增
  • add( )一次点击加一个元素
  • update( ) 一次添加至少一个 括号里面放可迭代的对象
• 删除
  • remove( )一次删除一个指定元素，如果指定元素不存在就抛出KeyError
  • discard( )不抛出
  • pop( )删除任意元素，栈顶的？
  • clear( )懂得都懂

集合间的关系

• 是否相等用 == 和 != 判断
• 是否是自己 issubset( )
• 是否是超集 issuperset( )
• 是否有交集 isdisjoint( )

集合的数学操作

• 交集 intersection( ) 或者使用运算符 &
• 并集 union( ) 或者使用运算符 |
• 经过集合操作，地址不发生变化
• 差集 difference( )，或者是运算符 -
• 对称差集 symmetric_difference( )

集合生成式

{i*i for i range(1,10) }

字符串

• 字符串在python中时基本数据类型，是一个不可变的字符序列

• 字符串的驻留机制。。。

• 字符型的列表，后面的不做赘述，有需要直接查API

• 查询，大小写转换，内容对其劈分，各种判断（是否合法），替换与合并，比较，切片，格式化，编码与解码（用于网络传输）

函数

函数的创建和调用

def 函数名（[输入参数]）:

​ 函数体

​ return xxx

def calc(a,b):
    c = a+b
    return c
result = calc(10,20)

函数调用的参数传递

• 位置实参，根据形参对应的值进行参数传递

• 关键字实参，根据形参的名称景行参数传递

  calc(b=10,a=10) # 怎么说呢，感觉很诡异
  

• 参数传值传的是地址，可以间接改变value

• 函数定义时，给形参设定默认值，只有与默认值不符的时候才需要传递实参

• 个数可变的我位置参数

  • 定义函数时，无法确定传递的位置参数的个数时，使用可变的位置参数
  • 使用*定义个数可变的位置参数
  • 参数值会是一个元组

• 个数可变的关键字形参

  • 结果为一个字典（），传的是键值对，关键字形参本身就是键值对er

函数的返回值

• 函数返回多个值时，结果为元组

变量的作用域

• 程序代码能访问该变量的区域
• 局部变量
  • 在函数内定义并使用的变量，只在函数内部有效，局部变量使用global生命，这个变量就会成为全局变量
• 全局变量
  • 函数体外定义的变量

BUG

面向对象

类

• 不同的数据类型属于不同的类
• 可以使用内置函数查看数据类型

对象

• 类的实例

类的创建

class student:
    native_place = "taiyuan" # 直接卸载类里面的变量成为类属性
    def __init__(self,name age): # 初始化方法
        # 在类之外定义的称为函数，在类内部定义的成为方法
        self.name = name
        self.age = age
    @staticmethod
    def method():
        print("Static method")
    @classmethod
    def cm(cls):
        print("Class method")
        

对象的创建

stu1 = Student("zhangsan",18)
# 实例对象有类指针指向类对象
stu.eat()

类属性

• 在方法外定义的属性——在类体内直接定义
• 被所有的该类对象共享，当然，允许修改

类方法

• 使用@classmethod修饰的方法，使用类名可以直接访问

  Student.cm( )

• 静态方法同上，修饰有所不同

动态的绑定属性和方法

stu2.gender = "girl" # 直接绑定到实例化的对象上
def show():
    print("show ")
    
 stu2.show = show # 完成方法绑定

封装

• 在python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象的外部被访问，前面使用两个“ - “
• 但是仍然可以通过 Objname._ClassName__variable_name 访问

继承

• 如果一个类没有继承任何类，那么它默认继承object

• 定义子类是，必须在其构造函数中调用父类的构造函数

  class Student(People):
      def __init__(self,name,age,score):
          super().__init__(name,age)
          self,score = score
  

方法重写

• 在子类里面把父类的方法重新写一遍就完了呗，或i用super( ).

object

• object类是所有类的父类，一次所有类都具有object类的属性和方法
• 内置函数dir( )可以查看指定对象的所有属性
• _str() 同toString( )

多态

• 你不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量调用方法，在运行中根据变量所引用对象的类型，动态地决定调用哪个对象中的方法

• 静态语言实现多态的三个条件

  • 继承
  • 方法重写
  • 弗雷引用指向子类对象

• 动态语言崇尚”鸭子类型“，当看到一只鸟走起来像鸭子、游泳起来像鸭子，那么这只鸟就可以被称为鸭子。不关心对象是什么类型，到底是不是鸭子，只关心对象的行为。

• 只要有相关的方法就行，不在乎有没有继承关系。0

特殊方法和属性

 obj.__ dict__ #获得类对象或者实例对象所有的属性，返回值是一个字典
 obj.__class__# 获得对象所属的类
 obj__base__ # 获得对象弗雷的一个元组
 obj.__mro__ # 查看类的继承结构
 obj.__subclasses__() # 返回子类的列表

def __init__(self,vars):
    obj.var = var # 用于定义类成员变量及其初始化
__add__() # 运算符重载
__len__() # 定义如何计算长度

模块化编程

模块

• Moudles

• 一个模块可以有很多个函数，类，语句什么的，一个py文件就是一个模块

• 方便其他程序和脚本的导入并使用

• 重用性，方便管理

导入

import math # 导入数学计算模块
from  math import pi # 导入math中的pi