Python3学习笔记#

写在前面
最近打CTF已经遇到瓶颈了，简单的、考点比较单一的题能打，但是比赛现在的web题都是综合性比较好的，自己写脚本的水平也是不太行，所以准备打一下Python的基础，之后开始复现那些高水平的web题

简介#

解释型语言：开发过程没有编译环节，类似的有PHP、Perl
交互式语言：在命令行、终端中，可以在一个Python提示符>>>后直接执行代码
面向对象语言：Python支持面向对象的风格或代码封装在对象的编程技术

开发环境#

选择的集成开发环境：PyCharm

基础语法#

标识符#

第一个字符必须是字母表中的字母或者下划线_
其他部分可以是字母、数字、下划线、中文
标识符对大小写敏感

保留字#

1
标准库里面有一个keyword模块，可以查看当前版本所有关键字
2
>>> import keyword
3
>>> keyword.kwlist
4
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
5
# Python3.7

注释#

1
# Python中单行注释以#开头
2
# 第一个注释
3
print ("Hello, Python!") # 第二个注释

行与缩进#

1
# Python以缩进来表示代码块，不用{},同一个代码块的语句必须包含相同的缩进空格数
2
if True:
3
  print ("True")
4
else:
5
    print ("False")
6
# Python一般是一行写完一条语句，可以用反斜杠\来实现多行语句
7
total = item_one + \
8
    item_two + \
9
      item_three
10
# 在[]、{}、()的多行语句中，不用反斜杠\
11
total = ['item_one', 'item_two', 'item_three',
12
        'item_four', 'item_five']

数字类型#

有整数、布尔、浮点数和复数

int：如1，只有长整型
bool：True或者False
float：1.23、3E-2
complex：1+2j、1.1+2.2j

字符串#

单引号和双引号一样
转义字符\
字符串可以用+连接，用*重复
Python中的字符串不能改变，且没有单独的字符说法，一个字符就是一个长度为 1 的字符串
字符串截取语法：==变量[头下标:尾下标<步长>]==

Python的字符串是左包含的，从左往右以 0 开始，从右往左以 -1 开始

1
str = 'C1everF0x'
2
print(str)
3
# 结果是 C1everF0x
4
print(str[2:5])
5
# 结果是 eve
6
print(str[0:-1])
7
# 结果是 C1everF0

空行#

函数之间、类的方法之间用空行分隔，表示一段新的代码开始，方便以后代码的维护和重构

print#

print输出默认换行，不换行要在变量末尾加上 end=“ ”

import和from…import#

用于导入相应模块

1
import somemodule  # 导入整个模块，引用时格式为：somemodudle.somefunction()
2
from somemodule import somefunction  # 从某个模块中导入一些函数，引用时格式为：somefunction()
3
from somemodule import *  # 导入某个模块全部函数，引用时格式为：somefunction()
4
import somemodule as abc  # 作用是自定义模块名字，在引用时格式为：abc.somefunction()

数据类型#

其实这六个数据类型，其实都是Python定义的内建类，每一个变量（对象）其实就是类的实例化
即，所有的字符串都是str类的实例，所有的列表都是list类的实例

不可变	可变
Number	List
String	Dictionary
Tuple（元组）	Set（集合）

Number#

int float bool complex 四种类型，其中int只有长整型
加减乘除正常用，/返回浮点数，//返回整数
数字类型值不可变的原因就是，只要两个变量的值相同，那么他们的==ID(地址)==就是相同的
```
1
>>> b = 5
2
>>> a = 5
3
>>> id(a)
4
162334512
5
>>> id(b)
6
162334512
7
>>> a is b
8
True
```

String（上面字符串）#

Tuple（元组）#

用()表示，比如('abcd', 786, 2.23, 'C1everF0x', 70.2)就是一个元组
截取、索引和切片方法和字符串一样

构造包含 0 个或 1 个元素的元组语法规则比较特殊

1
tup1 = ()  # 空元组
2
tup2 = (20,)  # 含一个元素的，需要在元素后面添加逗号

List（列表）#

用[]表示，比如[ 'abcd', 786 , 2.23, 'C1everF0x', 70.2 ]就是一个列表
截取、索引和切片方法和字符串一样

Set（集合）#

用{}或者set()创建集合，空集必须用set()，因为{}是用来创建空字典

字典#

字典包含在{}中，每个键值key=>value 对用冒号: 分割，每个对之间用逗号分割
键必须是唯一的，值不是唯一的
键的数据类型只能是字符串或数字，值可以是任何数据类型

基础语法#

跟C语言差不多，不记上来了

函数#

自定义函数以def开头，接函数名，接(参数列表)，接:
return [表达式]表示结束函数，返回一个东西，如果没有则是返回None
```
1
  def 函数名 (参数列表):
2
  函数代码
```

学到这里的时候发现有一个概念
Python里面变量是没有类型的，类型是属于对象，其中就有可更改对象和不可更改对象

不可变对象：数字、字符串、元组

可变对象：列表、集合、字典

本质区别
当给不可变对象重新传值的时候，不是修改了变量的值，而是重新生成了一个新的对象，然后再让变量指向新的内存地址，==其内存地址发生了改变==
当给可变对象重新传值的时候，是真正修改了对象的值，没有重新生成一个新的对象，变量前后指向的是同一个内存地址，==其内存地址没有发生改变==

参数#

必须参数#

顺序要对，调用数量要对，数据类型也要对

关键字参数#

在调用时，允许参数顺序和函数声明的时候不一样，解释器能够自动匹配

1
def printsomething( name, age ):
2
# 打印任何传入的字符串
3
   print ("名字: ", name)
4
   print ("年龄: ", age)
5
   return
6

7
#调用printsomething函数
8
printsomething( age=19, name="C1everF0x" )
9

10
# 结果
11
# 名字:  C1everF0x
12
# 年龄:  19

默认参数#

使用函数传参的时候没有传具体值进去，就会使用默认值，即函数声明时参数列表里面已经设置好的那个值

默认参数必须放在最后，不然报错

1
def printsomething( age, id = C1everF0x ):
2
# 打印函数，年龄和id
3
  print ("年龄：", age)
4
  print ("id：", id)
5
  return
6

7
# 调用printsomething函数
8
printsomething( age=19, id="Oui0jr")
9
# 结果是：
10
# 年龄：19
11
# id：Oui0jr
12
printsomething( age=19, id)
13
# 结果是：
14
# 年龄：19
15
# id：C1everF0x

不定长参数#

当你不知道你要传多少、传什么类型的参数进去的时候可以采用，以存放所有未命名的参数

加了星号*的参数是以元组形式导入

语法为：def 函数名([常规参数], *vartuple):

1
def printsomething( id=C1everF0x, *vartuple ):
2
# 打印函数，id、年龄和水平
3
  print ("输出：")
4
  print (id)
5
  print (vartuple)
6

7
# 调用printsomething函数
8
printsomething( id, 19, "弟弟")
9
# 结果是
10
# 输出：
11
# C1everF0x
12
# (19,"弟弟")

加了两个星号**的参数是以字典形式导入

语法为：def 函数名([常规参数], **vartuple):

1
def printsomething( id, **vardict ):
2
# 打印任何传入的参数
3
   print ("输出: ")
4
   print (id)
5
   print (vardict)
6

7
# 调用printsomething函数
8
printinfo(C1everF0x, age=19,lever="弟弟")
9
# 结果是：
10
# 输出:
11
# C1everF0x
12
# {'age': 19, 'level': "弟弟"}

单独一个星号*不带参数，调用时必须传==关键字==进去

语法为：def 函数名([常规参数], *):
```
1
def f(a,b,*,c):
2
  return a+b+c
3
f(1,2,3)   # 报错
4
f(1,2,c=3) # 正常
5
# 结果为6
```

匿名函数#

用lambda来创建匿名函数
创建出来的函数只是一个表达式，且不能访问自己参数列表以外的或全局命名空间里面的参数
```
1
lambda 参数1,参数2,...参数N:表达式
```

模块#

是一个包含了所有自定义的函数和变量的文件，后缀名是.py，可以被别的程序引入来使用其中的函数
dir()函数可以看到模块内定义的所有名称

面向对象#

~~企业级理解~~：
面向对象就是让每一个类都只做一件事，面向过程就是让一个类越来越全能，一个人做完全部的事情
摇(狗尾巴)——面向过程编程
狗.摇尾巴()——面向对象编程
找一个会做家务的男朋友，再找一个月薪20k的男朋友，再找一个会做饭的男朋友，最后找一个老实不花心的男朋友，不要让他们四个人同时见面——面向对象编程
找一个会做家务、月薪20k、会做饭、老实不花心的老公——面向过程编程

1
# 语法
2
class ClassName:
3
    方法1:
4
        xxxxxx
5
    方法2:
6
        xxxxxx
7
    属性1
8
    属性2

类的对象可以引用类的属性和方法
类的方法与普通的函数只有一个特别的区别——必须有一个额外的第一个参数名称, 按照惯例它的名称是self，也可以是其他的名字

类的方法#

一般方法#

在类的内部，用def定义方法，类的方法必须包含参数self而且必须是第一个参数，self表示的是类的实例（对象）

静态方法#

用@staticmethod装饰不带self参数的方法，可以没有参数，可以直接用类名来调用

类方法#

用@classmethod装饰，默认有一个cls参数，可以被类和对象调用

专有方法#

__init__ 构造函数，在生成对象时调用
__del__ 析构函数，释放对象时使用
__repr__ 打印，转换
__str__输出字符串
__setitem__按照索引赋值
__getitem__按照索引获取值
__len__获得长度
__cmp__比较运算
__call__函数调用
__add__加运算
__sub__减运算
__mul__乘运算
__truediv__除运算
__mod__求余运算
__pow__乘方

Python 3.7版本

类的属性#

公有属性（在类的外部可以直接访问）#

跟定义变量一样

a = 0

私有属性（在类的外部不可以直接访问）#

变量名字前面加俩下划线

__a = 0

继承#

单继承#

1
# 语法
2
class sonClassName(fatherClassName):

直接贴段代码例子

1
#类定义
2
class people:
3
    #定义基本属性
4
    name = ''
5
    age = 0
6
    #定义私有属性,私有属性在类外部无法直接进行访问
7
    __weight = 0
8
    #定义构造方法
9
    def __init__(self,n,a,w):
10
        self.name = n
11
        self.age = a
12
        self.__weight = w
13
    def speak(self):
14
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
15

16
#单继承示例
17
class student(people):
18
    grade = ''
19
    def __init__(self,n,a,w,g):
20
        #调用父类的构函
21
        people.__init__(self,n,a,w)
22
        self.grade = g
23
    #覆写父类的方法
24
    def speak(self):
25
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
26

27
s = student('C1everF0x',10,60,3)
28
s.speak()
29
# 结果是：C1everF0x 说: 我 10 岁了，我在读 3 年级

多继承#

1
# 语法
2
class sonClassName(father1ClassName,father2ClassName)

直接贴段代码例子

1
#类定义
2
class people:
3
    #定义基本属性
4
    name = ''
5
    age = 0
6
    #定义私有属性,私有属性在类外部无法直接进行访问
7
    __weight = 0
8
    #定义构造方法
9
    def __init__(self,n,a,w):
10
        self.name = n
11
        self.age = a
12
        self.__weight = w
13
    def speak(self):
14
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
15

16
#单继承示例
17
class student(people):
18
    grade = ''
19
    def __init__(self,n,a,w,g):
20
        #调用父类的构函
21
        people.__init__(self,n,a,w)
22
        self.grade = g
23
    #覆写父类的方法
24
    def speak(self):
25
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
26

27
#另一个类，多重继承之前的准备
28
class speaker():
29
    topic = ''
30
    name = ''
31
    def __init__(self,n,t):
32
        self.name = n
33
        self.topic = t
34
    def speak(self):
35
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
36

37
#多重继承
38
class sample(speaker,student):
39
    a =''
40
    def __init__(self,n,a,w,g,t):
41
        student.__init__(self,n,a,w,g)
42
        speaker.__init__(self,n,t)
43

44
test = sample("C1everF0x",25,80,4,"Python")
45
test.speak()   #方法名同，默认调用的是在括号中排前的父类的方法
46
# 结果是：我叫 C1everF0x，我是一个演说家，我演讲的主题是 Python

重写父类方法#

可以在子类里面重写父类的方法，方法名一样
要调用父类被覆盖的方法的时候可以使用super()函数

音乐

音乐

Python基础学习笔记

Python3学习笔记#

简介#

开发环境#

基础语法#

标识符#

保留字#

注释#

行与缩进#

数字类型#

字符串#

空行#

print#

import和from…import#

数据类型#

Number#

String（上面字符串）#

Tuple（元组）#

List（列表）#

Set（集合）#

字典#

基础语法#

函数#

参数#

必须参数#

关键字参数#

默认参数#

不定长参数#

匿名函数#

模块#

面向对象#

类的方法#

一般方法#

静态方法#

类方法#

专有方法#

类的属性#

公有属性（在类的外部可以直接访问）#

私有属性（在类的外部不可以直接访问）#

继承#

单继承#

多继承#

重写父类方法#

文章分享