Python学习 —— Python的基础知识

Python变量

Python变量无需声明即可赋值,变量的类型可以动态改变。同一变量名可以在程序运行的不同阶段代表不同形式的值（整型，浮点，列表，元组等）

message=“Hello Word” #字符串类型
num=1314 #数字类型
sum=52.0

• Number数字类型

  • 整数：a=1000此处a就是整型数据
  • 浮点数：a=3.1415926此处a是浮点型数据
  • 复数：由实数和虚数两部分组成，如：163+2j
  • 布尔类型：只有True（1）和False（0）两个值。Python中没有真正的布尔类型，而是用数字0来表示False，数字1来表示True，所以bool是Number类型

• 字符串
  Python 字符串时不可变的，每当修改字符串时，内存中实际上都是创建了一个全新的字符串。
  1、在Python语言中，用引号括起来的都是字符串，其中的引号可以是单引号，也可以是双引号或者是三引号。这种灵活性可以让字符串中包含引号和撇号

  print('"Python" is easy to learn!')
  输出结果：
  "Python" is easy to learn! #注意Python左右的双引号也被输出了
  

  2、Python使用（+）来拼接字符串，但是如果需要循环动态添加使用+来拼接字符串会使效率低下。可以用str,join()方法，它接受可迭代的字符串作为参数，返回合并后的字符串。

  str_1='Test'
  str_2="Python"
  print(str_1+"-------"+str_2)
  print(str_1.join(['some','learn','values']))
  输出结果：
  Test-------Python
  

  3、删除空白：lstrip() 删除头的空白，strip() 删除尾的空白
  4、自然字符串：通过给字符串加上前缀r或者R来指定，此时转义字符失效，Python将会视其为普通字符串（但引号任然需要转义）。多用在指定路径时使用

  str=r"\"Hello\' World\""
  print(str)
  输出结果：
  \"Hello\' World\"
  

  5、字符串常用方法：

  • in：检测指定字符串是否存在于字符串序列中
  • len()：获取字符串序列长度
  • min()/max()：取最小/最大的字符
  • strip()：删除字符串前后的空白
  • index()：查找指定子串在字符串中出现的位置，如果没有找到则引发ValueError错误
  • replace()：使用指定的字串替换字符串中的目标子串
  • split()：字符串分割
  • format字符串格式化string.format()

Python运算符

• Python数字运算和C类似：包括+, -, * 和 /，但是在除法中总是返回一个浮点数
• 如果想要整数除可以使用预算符//.
• Python 可以使用 ** 操作来进行幂运算：5**2=25
• 逻辑运算符（类比&&、||、!）：
  • and：与，任一操作数中为False，结果返回False
  • or：或，任一操作数中为True，结果为True
  • not：非，只需要一个操作数，对原操作数取反。如果操作数为True，则返回False；如果操作数为False，则返回True
  • <<,>>：左移和右移
  • ~x：对x按位求反
• in运算符：判断成员是否位于序列中

Python 列表

在Python中，用方括号（[]）来表示列表，并用逗号来分隔其中的元素（列表类似C#中数组的概念）。在Python列表这种数据类型中，每一个数据元素不一定是同一种数据类型。

test=['Python',23,"Learning","Work"]

• 访问列表元素：列表元素的访问和数组类似，只需要传入索引即可：
  Python可以反向索引，最后一位是-1，倒数第二位为-2，以此类推

  print(test[0])
  print(test[-1])
  输出：
  Python
  Work
  

• 修改列表元素：修改列表元素的方法和访问类似只需要将列表相应索引的值修改了即可：

  test[1]=56 #列表test中索引为1的元素的值将会更改为56
  

• 添加列表元素：

  • append(data)：在列表的尾部添加元素

  test.append("YY")
  print(test)
  输出：
  ['Python', 23, 'Learning', 'Work', 'YY']
  

  • insert(index,data)：在列表指定的位置添加元素

  test.insert(1,"YY")
  #此时test中的数据为：['Python', 'YY', 23, 'Learning', 'Work']
  

• 删除列表元素：

  • del(index)：删除指定索引的元素

  del test[2]#此时test元素为：['Python', 23, 'Work']
  

  • 使用pop()删除元素：pop() 方法可以删除列表末尾的元素，并返回末尾元素的值

    endstr=test.pop();
    print(endstr)
    print(test)
    输出结果：
    Work
    ['Python', 23, 'Learning']
    

    如果在**pop()**方法中传入索引，该函数则是删除指定索引的元素并返回

  • remove(data)：删除指定元素

    test.remove(23)
    print(test)
    输出结果：
    ['Python', 'Learning', 'Work']
    

• len() ：确定列表长度

• 切片：Python在对列表的访问时支持切片操作[startindex]。第一个冒号前后分别指定切片的开始和结束，如果没有指定开始默认从零开始，如果没有指定结尾默认到列表的最后一个元素。index为步进值默认为1

  test=['Python',23,"Learning","Work","35","Hello","World"]
  print(test[1:3]) #输出：[23, 'Learning']
  print(test[2:]) #输出：['Learning', 'Work', '35', 'Hello', 'World']
  print(test[:4]) #输出：['Python', 23, 'Learning', 'Work']
  print(test[:6:2]) #输出：['Python', 'Learning', '35']
  

元组

元组看起来和列表类似，使用圆括号来标识。

student=("Angle",88,"女")

元组的操作和列表类似，但是元组的内容不可修改，所以元组的元素是不能增、删、改的。

字典

在Python中，字典是一系列的key-value键-值对（键-值之间用冒号分隔），用花括号{}标识

student={'name':"YY",'age':18,'sex':'女','grade':88}

• 字典访问：将关键字放入字典名的方括号内print(student['name'])

• 字典添加：直接对指定的关键字赋值

student['pro']="student"
#此时字典内容为：
{'name': 'YY', 'age': 18, 'sex': '女', 'grade': 88, 'pro': 'student'}

• 字典删除：del 删除指定的键del student['age']
• 字典遍历：

student={'name':"YY",'age':18,'sex':'女','grade':88}
for k,v in student.items():
    print("Key:"+str(k)+"\t"+"Value:"+str(v))
输出结果：
Key:name        Value:YY
Key:age Value:18
Key:sex Value:女
Key:grade       Value:88

函数

Python使用def来定义函数

• 函数返回值可以是0或者多个，如果是多个返回值，Python会自动将多个返回值封装成元组

def PrintHelloWorld(*parameter): 
	#def后紧跟函数名，冒号后面所以的缩进构成了函数体，*parameter可变参数，可以是任意的数量和类型
	#参数也是可以name="YHZ",传参时可以指定给参数复制，不用按照函数定义的顺序赋值
    print("Hello World ")

• Python 函数传参，可以按照位置传参数，可以通过名字传参数

def show(name,age,sex):
    print(name,age,sex)

show("A",18,"男")
show(age=21,name="H",sex="女")

• 除了def语句外，Python还提供了一种生成函数lambda 表达式：

def add(x,y,z):
	return x+y+z
f=lambda x,y,y:x+y+z #此时f的功能和add函数的功能就是一致的
f(2,3,4)
add(2,3,4)

类

和C++/C#类似，Python也是一种面向对象的设计语言，包含3个基本要素：数据抽象化（封装）、继承和多态（动态绑定）。用Class来进行定义。_init_构造函数， _ del _析构函数

• 类变量：在类空间或通过类引用赋值的变量
• 实例变量：通过对象引用或self引用赋值的变量

class person:
	#两个下划线开头，声明该属性为私有（private），不能在类的外部被使用或直接访问；
	#一个下划线开头，声明	该属性为保护类型（protect）只能在该类和改类的派生类中访问；
	#没有下划线开头的就是共有属性（public）可以在类的内外部访问。
    name="XXX" #类变量
    age=0
    def __init__(self,m_name,m_age):
        self.name=m_name #实例变量
        self.age=m_age
    def GetName(self):
        return self.name
    def GetAge(self):
        return  self.age
    def ShowMessage(self):
        print("{0} is {1} years old!".format(self.name,self.age))

• 同样Python中的类也支持继承，Python支持多继承（如无必要，尽量避免使用多继承）：

class student(person):
    __source=0
    def __init__(self,m_name,m_age,m_sourece):
        self.__source=m_sourece
        super().__init__(m_name,m_age)
    def ShowMessage(self):
        print("{0}'s source is {1}".format(self.name,self.__source))
class teacher(student,person):
    def __init__(self,m_name,m_age,m_sourece):
        super().__init__(m_name,m_age,m_sourece) #调用基类构造方法
		

测试代码：

a=person("Angle",18)
a.ShowMessage() #输出：Angle is 18 years old! （输出的person的）
print(person.name) #输出 ：XXX 
print(a.name) #输出 ：Angle
b=student("Bable",12,85)
b.ShowMessage() #输出：Bable's source is 85
super(student,b).ShowMessage()#超类访问 输出：Bable is 12 years old!
print(student.name) #可以理解为全局静态变量
print("-----------------------")
t=teacher("Bable",12,85)
t.ShowMessage() #输出：Bable's source is 85
super(student,t).ShowMessage()#输出 ：Bable is 12 years old!

• 定义类方法，需要用@classmethod 修饰，需要定义一个cls形参

class User:
    @classmethod
    def info(cls):
        print("调用类方法")

User.info();

• 定义静态方法，用@staticmethod ，不需要参数。类方法需要形参，Python会自动绑定，而静态方法则不会。

函数装饰器

当程序使用“@函数名”（此处设置为函数A）装饰另一个函数（此处设置为函数B），实际上的作用如下：
（1）将被装饰的函数（函数B）作为参数传递给@符号引用的函数
（2）将函数B替换成第一步的返回值

# 作为函数装饰器的函数必须要有一个参数
#Python会将装饰的返回值替换原来的函数
def foo(fn):
    print("调用装饰器函数")
    def add(*args):  
        print("装饰器中调用")
        fn(*args)
    return add;
@foo
def test(a,b):
    print("计算结果")
    print(a+b)
test(3,2)
测试结果：
调用装饰器函数
装饰器中调用
计算结果
5