python 入门知识点整理

变量和赋值

Python中的变量不需要声明, 直接定义即可. 会在初始化的时候决定变量的 “类型”
使用 = 来进行初始化和赋值操作

定义变量时不用写类型，这个类型会在初始化的时候定义
关于 ； 这个可写也可不写，建议不写
光标放在下面 num和pi 上面会显示这个变量的类型

关于浮点数，在C++和java中分为 float和double
python不区分float和double，一律 视 为float 但是是 double

num = 10
pi = 3.14
name = '张三'

num = 10
num += 1
print(num)
输出：11

注意：在python中没有++ –
python将++ – 视为两个 加号和减号

num = 10 # 这是一个数字
num = ‘10’ # 这是一个字符串
但是这样的代码可以运行
原因：
python是一个动态类型的语言
一个变量在运行过程中，类型可以发生变化

C++和jave都是静态类型
静态代码是你代码写好，类型确定，你在运行过程中，类型不能发生变化

变量命名
1.数字字母下划线构成，数字不能开头
2.最好能够见名知意

延伸：变量名能否使用拼音
大部分情况用英语，不得已的情况下可以使用拼音

---

认识‘数字’

认识 “数字”
Python没有int, float, 这样的关键字,
但是实际上数字的类型是区分 “int” “float” 这样的类型的.
使用内建函数 type 可以查看变量的类型
延伸:内建函数,python本身自带的函数,不用包含其他模块就能使用的

num = 10
print(type(num))
输出:<class ‘int’>
class 表示类
则:在python中int这样的类型,本质上也是一个对象

num = 10.0
float 

复数
num = 10 + 5j
print(type(num))
输出:<class 'complex'>

延伸:python2中,注释后面不能输入 中文,python可以使用
python中的int不仅是一个四个字节表示的,而是一个无限大的数字

---

字符串

Python中可以使用 单引号(’), 双引号("), 三引号(’’’/""") 来表示字符串.
这三种字符串的区别, 我们后面再讨论

如果字符串内容中就包含了引号的话,就可以灵活搭配使用了
name = ‘zhangsan’
name = “”“hehe’’’ my name ‘is’ zhang “da” san’’'hehe”""
print(name)
输出:hehe’’’ my name ‘is’ zhang “da” san’’'hehe

延伸：内建函数
python中内置自带的函数，一上来就能直接使用
1.print 2.type 3.len

求字符串长度
name = ‘abcdefg’
print(len(name))
输出：7
问题这里面有没有\0?
C语言之后，没有任何一种语言包含\0这样的设定

取下标
name = 'abcdef'
print(name[1])
输出：b

name = 'abcdef'
print(name[100])
输出：IndexError: string index out of range
索引器错误：字符串索引超出范围

name = 'abcdefg'
print(name[-1])
输出：g
下标为负数：想当于：len(name)负数

切片： slice
name = 'abcdefg'
print(name[1:3])
输出：bc
[]内容为：左闭右开区间，里 面的数字也可以为负数，
也可以省略：省略前面， 相当于从零开始，省略后面，相当于到最后结束

a = 'hello'
b = 'world'
print(a+b)
输出：helloworld

a = 'hello'
print(a*3)
输出：hellohellohello
数字在后，字符串在前

num = 10
a = 'num = %d' % num
print(a)
输出：num = 10
不推荐使用这种格式，这种格式容易写错

num = 10
a = 'num = {}'.format(num)
print(a)
输出：num = 10
也不太推荐使用这种方式，因为这种方式有点麻烦

num = 10
a = f'num = {num}'
print(a)
输出：num = 10
这种写法在现在很多情况下都有，
C++和java没有，其余大部分都有
这种写法在3.6以后才支持

---

布尔类型

True and False

a = True
print(True)
print(type(a))
输出：
True
<class 'bool'>在这里插入代码片

a = True
print(a+1)
在C++中True代表1，False代表0，python也一样
在java中这个写法不成立

---

输入输出

a = 'name'
print(a)
输出：
name

print(a,end = '')
输出：name
但是我自己写的代码中，这两个都没有下一行，可以推断，这个新版本改了

输入：
s = input("请输入一个字符串：")
print("s: ",s)

错误示例
s = input("请输入一整数:")
print("result: ",s + 100)
输出：TypeError: can only concatenate str (not "int") to str
不能够把整数和字符串进行相加

修改：
s = input("请输入一整数:")
print("result: ",int(s) + 100)

---

注释

Python的源代码默认只支持ASCII, 所以如果要包含中文,
需要在代码文件最开头的地方注明 # --coding: UTF-8 --
或者 #coding:utf8
这个只针对python2，python3就没有这种问题，这个可写可不写

---

操作符

/ 是 “精确除法”
print(1/2)
输出：0.5

/ / 是 “整除”. 会对结果进行取整
print(1//2)
输出：0

其余都一样

** 表示乘方运算(记得Python的数据无上限)
print(2**3)
输出：8

Python也支持标准的比较运算符.
< >= <= == != 这些运算符的表达式的结果, 是一个布尔值

print(1<4<3)
在C++中 1<4 成立，所以返回1，然后1<3 成立，所以最终返回True
在python中这个直接返回 False

Python也支持逻辑运算符. and or not ----》 && || ！
上面的代码可以写成：
print(1<4 and 4<3)

字符串之间可以使用 == != 来判定字符串的内容是否相同
print(‘haha’ == ‘hehe’)

字符串之间也可以比较大小. 这个大小的结果取决于字符串的 “字典序”
print(‘haha’ > ‘hehe’)

---

列表/元组/字典

列表和元组类似于C语言中的数组.
使用 [] 来表示列表, 使用 () 来表示元组.

列表 list
本质上就是我们的数组，但是python中没有数组

a = [9,5,2,7]
print(a[1])
print(a[-1])
print(a[1:-1])
print(len(a))

元组
a = (9,5,2,7)
print(a[1])
print(a[-1])
print(a[1:-1])
print(len(a))

区别：
a = [9,5,2,7]
a[0] = 100
print(a[0])
# 

b = (9,5,2,7)
b[0] = 100
print(b[0])
TypeError: 'tuple' object does not support item assignment
tuple这个元素不能被修改

则：列表可以被修改
元组不能被修改，只能构建出新的元素对象

列表和元组里面的元素不一定是相同的类型
a = [9,‘hehe’,2,7]
这也是可以的----》动态类型

字典：

字典是Python中的映射数据类型. 存储键值对(key-value).
几乎所有类型的Python对象都可以用作键. 不过一般还是数字和字符串最常用.
使用 {} 表示字典

这个格式在json中有，
a = {
‘ip’:‘127.0.0.1’,
‘port’:80
}
print(a[‘port’]) # 输出：80
底层本质上就是 哈希表
哈希表中查找一个元素的时间复杂度是：O（1）

---

引用

Python中可以用 id 这个内建函数, 查看变量的 “地址”.
python中的引用和java是一样的，
和C++的差别还是挺大的

id 也是一个内建函数，能够查看一个变量的身份标识
id只是一个身份标识，他和地址没有关系
地址：他有两重含义
1.身份标识：两个东西的地址相同，他就是同一个玩意
2.地址也表示你这个对象在内存中储存在内存的哪一个位置？

a = 100
b = a
print(id(a))
print(id(b))
输出：
2048510350800
2048510350800
则证明：a和b 是同一个对象

---

代码块及缩进

Python中使用缩进来表示代码块. 相当于天然从语法的角度规定了代码风格.
Python是独一无二的使用缩进而不是{}的, 这就避免了一场党派之争

---

if语句

result = input("你会认真学习吗？1.会的 0.不会")
if result == '1':
    print('牛逼')
    print('继续努力')
elif result == '0':
    print('菜鸟')
else:
    print('输入错误')

switch语句在python中没有
do… while 在python中也没有

---

while循环

while循环语句和if语句语法类似.
只要表达式的值非0或者为True, 就会循环执行do_something

打印0-9
num = 0
while num < 10:
    print(num)
    num+=1
输出：竖着打印0-9

---

for循环

python 的for相当于C++ range based for
相当于JAVA中的for each

for num in range(0,10):
    print(num)
输出：打印0-9（竖着）

for 也可以遍历列表，元组，字典
a = [9,5,2,7]
for num in a:
    print(a)
输出：竖着打印0-9

字典：
a = {
    'ip':'127.0.0.1',
    'port':80
}
for key in a:
    print(key,a[key])
输出：
ip 127.0.0.1
port 80

延伸：127.0.0.1这个ip地址是什么意思？
环回IP，无论自己的ip是什么，都可以使用这个ip来访问自己

break，continue
打印0-10，遇见3的倍数就停下
for num in range(1,10):
    if num% 3 == 0:
        break
    print(num)
输出：
1
2

for num in range(1,10):
    if num% 3 == 0:
        continue
    print(num)
输出：1-8，没有3的倍数，（竖着打印）

---

pass语句

表示空语句
为了表示我们的语句格式能够正确

if x % 2 == 0:
    pass
else:
    do_something

---

列表解析 （列表推导）

需求：给定一个列表，列表中是一些数字，需要把其中的奇数数字
进行变换，然后生成一个新的列表，例如按照乘方的方式变换

#传统C语言思路
#append相当于C++中的push back
#就是插入到列表的最后
a = [1,2,3,4,5,6,7,8,9]
b = []
for num in a:
    if num % 2 == 0:
        continue
    num = num*num
    b.append(num)
print(b)
输出：[1, 9, 25, 49, 81]

python思路
a = [1,2,3,4,5,6,7,8,9]
b = [num ** 2 for num in a if num % 2 == 1]
print(b)
输出：[1, 9, 25, 49, 81]

这样的方式就叫做列表解析
我们可以通过一个表达式，通常是一个循环语句
来帮助我们生成一个新的列表

---

C语言里面叫做函数，java里面叫做方法

函数
def add(x,y):
    result = x + y
    return result

print(add(1,2))
print(add('hello','world'))
输出：
3
helloworld

也可以这样
def add(x,y):
    if x > 0:
        return 'aaa'
    if x<0:
        return -1
    result = x + y
    return result

函数重载
C++和java都有函数重载
函数名一样，参数要么是个数不一样，要么是类型不一样

def add(x,y):
    return x+y

def add(x,y,z):
    return x+y+z

print(add(10,20))
TypeError: add() missing 1 required positional argument: 'z'
add这个函数缺了一个参数 ’z'

则证明：
python不支持函数重载，
存在多个重名函数时，后者覆盖前者

默认参数
C++里面有，java里面没有

def add(x = 0,y = 0):
    return x+y

print(add(10))
print(add())
都可以

python中可以同时返回多个值
def get_point():
    x = 10
    y = 20
    return x,y

这种方式叫做：解包 unpack
x,y = get_point()
print(x,y)

如果不想要其中一个值可以：
_,y = get_point()

函数也是 “对象”. 一个函数和一个数字, 字符串一样, 都可以定义 “别名” 来引用它.

def get_point():
    x = 10
    y = 20
    return x,y

print(type(get_point))
输出：<class 'function'>

说明：他的类型是”<class ‘function’>
这个函数类型就说明可以把他这个函数作为另外一个函数的参数
也能作为另外一个函数的返回值

我们说这个函数也是一个对象，那么我们就可以
get_point. 来取到这里面的一些属性

---

文件操作

常规步骤：
1.打开文件 2.关闭文件 3.读文件 4.写文件

延伸：文件是存在磁盘上的
意思是：平时操作的变量，对象这些东西，这些都是在内存中
而我们的文件这是在磁盘上，也就是外存中
相比之下，我们访问变量要比访问文件更容易些
意思就是内存中更好访问，外存中更加困难
这个时候我们操作文件往往采取一种策略
先创建一个和这个文件相关的句柄再操作

文件打开
如果文件不存在，那么文件就打开不成功
f = open(“C:\Users\wyw15\Desktop\test.txt”,“r”)

输出：
FileNotFoundError: [Errno 2] No such file or diretctory:
“C:\Users\wyw15\Desktop\test.txt”
即：这个路径不存在

f = open(“C:\Users\wyw15\Desktop\test.txt”,“r”)
f.close()
我们创建一下这个文件
运行：不会有什么问题

文件打开之后，使用完毕一定要及时关闭
如果不及时关闭，我们再打开新文件就会打开失败
C++：在我们操作系统内核中，每个进程里面都有文件描述表
每次打开一个文件，需要在文件中占一个坑，但是这张表有长度上限
所以这个坑不能无限的挖，就只能关闭一个再打开一个
这种问题我们称为： 文件描述符泄露问题

当我们没有写这个 # f.close() 当这个文件的声明周期结束时，
这个文件就会被回收，回收时，也会被关闭
但是我们不能指望它，因为它什么时候关闭，我们不能人工关闭

f = open("C:/Users/wyw15/Desktop/test.txt","r")

for line in f:
    print(line)

f.close()
输出：输出文件里面的内容，
但是每一行中间都有空行

原因：因为我们读取这个文件时，这个文件每一行的最后包含\n
我们在打印的时候，print后面又会多一个\n

解决：
f = open("C:/Users/wyw15/Desktop/test.txt","r")

for line in f:
    print(line,end = '')

f.close()
输出：正常输出

另外一种读文件
f = open("C:/Users/wyw15/Desktop/test.txt","r")

readlines返回的是一个列表
lines= f.readlines()
print(lines)

f.close()
输出：['hello\n', 'world\n', 'aaa\n', 'bbb\n', 'ccc\n', 'aaa\n', 'ccc\n', 'bbb']

写文件
f = open("C:/Users/wyw15/Desktop/test.txt","w")

f.write('hello world')

f.close()
打开外部文件，我们会发现这个文件里面就只剩下了 hello world

---

统计文本中的词频

f = open("C:/Users/wyw15/Desktop/test.txt","r")

word_dirt = {}
for word in f:
    if word in word_dirt:
        word_dirt[word] += 1
    else:
        word_dirt[word] = 1

print(word_dirt)

f.close()
输出：{'hello\n': 1, 'world\n': 1, 'bbb\n': 1, 'ccc\n': 1, 'aaa\n': 1, 'bbb': 1}
问题：每个字符串后面都跟着一个\n,问如何去掉？

修改1：切片
f = open("C:/Users/wyw15/Desktop/test.txt","r")

word_dirt = {}
for word in f:
    word = word[:-1]
    if word in word_dirt:
        word_dirt[word] += 1
    else:
        word_dirt[word] = 1

print(word_dirt)

f.close()
输出：{'hello': 1, 'world': 1, 'bbb': 1, 'ccc': 1, 'aaa': 1, 'bb': 1}
不对，bb  bbb数据异常

修改二：
f = open("C:/Users/wyw15/Desktop/test.txt","r")

word_dirt = {}
for word in f:
    word = word.strip() # 去掉字符串两侧的空白字符
    print(word)
    if word in word_dirt:
        word_dirt[word] += 1
    else:
        word_dirt[word] = 1

print(word_dirt)
f.close()
输出：{'hello': 1, 'world': 1, 'bbb': 2, 'ccc': 1, 'aaa': 1}
延伸：空白字符：空格，tab 换行 垂直翻页符

---

模块

当我们一个项目的代码量较大的时候, 需要把代码放到多个不同的.py文件中
可以通过 import 关键字, 引用其他.py文件中的代码.
被引入的这个代码文件, 就称之为 “模块”.
被引入的文件, 去掉.py后缀名, 就是模块名

这里的import 不光是模块名，同时也是命名空间
我们知道函数名不能冲突，相同就会覆盖
calc：计算
import calc
print(calc.add(1,2))

一个模块要想被正确导入，必须放到合适的目录中
一个是test.py 和 calc.py 要在同意文件夹里面
或者是 系统目录（python计时器安装目录）