Python-基础语法

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

1. Python的安装

运行环境Python
开发环境PyCharm
官网

https://www.python.org/downloads/windows/
这个是下载Windows版本的

下载这个就可以了

勾选add，选择install

python --version

2. 安装PyCharm

官网

3. 创建项目

print('hello')

文件以py为后缀，或者不加后缀

4.基础语法

4.1 常量和表达式

Python中整数除以整数不会舍弃小数了
而且编程中没有四舍五入，所以最后为665，这是微小的误差

4.2 变量

avg = (1+2+3)/3
avg = avg**2
print(avg)

**2表示二次方，**3表示三次方

4.3 创建变量

a = 10

4.4 变量类型

变量类型由初始化值的类型决定

a = 10
print(type(a))

而且在python中int表示的数据范围是无穷
所以python里面没有long没有short

a = 0.5
print(type(a))

这个是浮点数，python中float是双精度，但是java中是单精度，所以我们不需要其他浮点数了

a = 'hello'
print(type(a))

字符串类型的话，可以使用单引号，也可以是双引号

a = "hello 'ck' "
print(a)
print(type(a))

可以用两个引号的目的是，这样就可以在字符串里面使用双引号或者单引号了
、

表示字符串还可以使用三引号，就是三个单引号或者双引号

a = ''' "hello 'ck' " '''
print(a)
print(type(a))

b = 'aaaa'
print(len(b))

len是求长度

b = 'aaaa'
print(len(b))
print(b+'ss')

这个是字符串拼接

对原来的没有影响
但是不能像java一样，字符串和int拼接

c = True
a = False
print(c)

True和False第一个字母是大写的

4.5 动态类型

就是在程序运行过程中类型可以改变
python中是动态类型

d = 10
print(type(d))
d = 'aa'
print(type(d))

java和c++中就是静态类型

d:int = 10
print(type(d))
d = 'aa'
print(type(d))

python中可以声明类型，但是还是动态类型

4.6 注释

就是一个#

"""
aaa
"""

这个是文档字符串（三个单引号也可以），和注释是一样的效果—》可以被识别。而#不能被识别

4.7 输出到控制台

a = 10
print(f"a={a}")

这个意思是格式化字符串
f就是format的意思
加了f的话，就可以用{}在字符串里面嵌入变量了

a = 10
print(f"a={a+10}")

4.8 从控制台输入

num  = input('请输入一个整数：')
print(f"num={num}")

input就是会等待用户输入，输入的值用num接收

num  = input('请输入一个整数：')
print(type(num))
print(f"num={num}")

但是input的类型为str

num  = input('请输入一个整数：')
num = int(num)
print(type(num))
print(f"num={num}")

这样前面加上（）就可以转化类型了

还有str(),float()

4.9 算术运算符

%是求余数

7%2=1

**就是进行乘方运算

print(4**2)
print(4**0.5)

没有三个*的说法

print(7//2)

这个表示取整

print(7//2)
print(-7//2)

这个表示是向下取整，就是往小的方向取整

4.9 关系运算符

不仅可以比较整数，还可以比较字符串

print('abc'>='abd')

比较中文是没有意义的

python用==和!=可以比较字符串的内容是否相同

浮点数用==来比较困难会有误差

print(0.1+0.2)
print(0.1+0.2==0.3)

print(-0.000001<(0.1+0.2)-0.3<0.000001)

python中是可以连续比较的

4.10 逻辑运算符

and , or , not

print(1<2 and 2<3)

print(1<2 <3)

都是一样的效果

注意and也是一样的，就是and左边错误了，右边就不用求值了

4.11 赋值运算符

就是=

左边必须是变量

变量之间可以连续赋值

a = b = 10

a,b = 10,20

就是a=10,b=20
这个是顺序赋值

a,b = b,a

这样就可以把a和b交换值了

a+=1

就是a=a+1
但是这样的话a肯定要提前定义过的

python中不能a++语法

++a

python要看做两个+号，值不变

后置的++会直接报错的

4.12 条件语句

a = input()
if(a == '1'):print(1)print(111)
elif(a == '2'):print(2)
else:print(3)
print(44)

4.13 缩进和代码块

if后面没有缩进的话，直接就报错了

缩进不合法也是错误的
缩进就是四个空格

if a=='1':if a=='2':print(2)print(1)
print(3)

可以没有括号

4.14 空语句

if a=='1':pass
else:print(2)

空语句就是pass

4.15 while循环语句

b=1
while b<10:print(b)b+=1

4.16 for循环

for i in range(1,11):print(i)

前闭后开
默认步长是1，这个是可以修改的

for i in range(2,12,2):`在这里插入代码片`print(i)

第三个参数就是步长

for i in range(10,0,-1):print(i)

步长也可以为负数
注意有个内建函数就是sum所以变量名不要用sum

4.17 break,continue

for i in range(10,0,-1):if i==10:continueelif i==5:breakprint(i)

i =1
while True:print(i)i = i + 1if i == 3:break

continue退出的是循环，不是if

4.18 其他方法

b = random.randint(1,6)
print(b)

这个是生成随机数
左闭右闭

import random

random这是一个模块，会自动导入的，pycharm

sys.exit(0)

这个是退出程序

4.19 函数定义

def theSum(a,b):return a+bprint(theSum(2,3))

def就是定义函数了

def the_sum(a,b):return a+bprint(the_sum(2,3))

函数名尽量小写
或者可以忽略错误

只是警告而已
形参和实参的个数应该相同
但是类型没有要求

但是还是不能int和str相加哈

def theSum(a,b):return a,bc,d = theSum(1,2)
print(c)
print(d)

这个就是多元赋值

直接return多个值

def theSum(a,b):return a,bc,_ = theSum(1,2)
print(c)

下划线来表示占位

外面定义的是全局变量，函数里面的是局部变量，函数里面可以访问全局变量，如果自己没有定义变量的话
只有函数定义得到变量才是局部变量，if，while定义的变量都是全局的

def theSum(a,b):global xx=20return a,btheSum(1,1)
print(x)

global 表示声明一个全局变量，但是必须调用函数了才可以声明

for i in range(1,11):pass
print(i)

python中只有函数会影响作用域

只有函数有局部变量

python函数也是可以递归的

4.20 函数参数默认值

def theSum(a,b=10):return a,b
print(theSum(1))

def theSum(a,b=10):return a+b
print(theSum(1))

默认值只能在后面，java不支持默认值的语法

4.21 关键字参数

def theSum(a,b):return a+b
print(theSum(b=20,a=10))

就是指定谁给谁参数赋值，顺序可以改变了

4.22 列表和元组

a=[]
b=list()
print(type(a))
print(type(b))

a=[1,2,3,4]
print(a)

a=[1,2,3,'hello',True]
print(a)

a=[1,2,3,'hello',True]
print(a[1])

a=[1,2,3,'hello',True]
print(len(a))

a=[1,2,3,'hello',True]
print(a[-1])

-1其实就是最后一个元素，就是length-1
-2就是倒数第二个

4.23 列表切片

a=[1,2,3,'hello',True]
print(a[1:3])

表示获取区间，前闭后开
下标1~3

a=[1,2,3,'hello',True]
print(a[1:])

下标1到末尾

a=[1,2,3,'hello',True]
print(a[:])

当然也可以写-1，-2

a=[1,2,3,4,5,6,7,8,9]
print(a[::1])

1表示步长，表示每隔一个元素取数据

a=[1,2,3,4,5,6,7,8,9]
print(a[::2])

a=[1,2,3,4,5,6,7,8,9]
print(a[::-1])

步长为负数，表示倒着取数据

a=[1,2,3,4,5,6,7,8,9]
print(a[:100])

切片可以大于len
但是a[]不能超过len

4.24 列表遍历

a=[1,2,3,4,5,6,7,8,9]
for element in a:print(element)

element就是列表中的每个元素
a其实就是一个可迭代对象

for i in range(0,len(a)):print(a[i])

也可以这样变量
这样可以修改列表的值
element不是列表中的值，只是赋值了

4.25 列表插入新增

a=[1,2,3,4,5,6,7,8,9]
a.append(10)
print(a)

就是尾差

a=[1,2,3,4,5,6,7,8,9]
a.insert(1,10)
print(a)

就是在下标为1位置插入数据

a=[1,2,3,4,5,6,7,8,9]
a.insert(100,10)
print(a)

下标太大就是插入末尾了

4.26 下标查找删除

a=[1,2,3,4,5,6,7,8,9]
print(1 in a)

这个是判断1是否在a里面

a=[1,2,3,4,5,6,7,8,9]
print(1 not in a)

判断是不是不存在

a=[1,2,3,4,5,6,7,8,9]
print(a.index(2))

这个就是返回2的下标

a=[1,2,3,4,5,6,7,8,9]
print(a.index(10))

直接就抛出异常了

a=[1,2,3,4,5,6,7,8,9]
print(a.pop())
print(a)

这个就是直接删除最后一个元素

a=[1,2,3,4,5,6,7,8,9]
print(a.pop(1))
print(a)

这个就是直接对应下标删除

a=[1,2,3,4,5,6,7,8,9]
print(a.remove(1))
print(a)

这个是删除值1

4.27 列表链接

a=[1,2,3,4,5,6,7,8,9]
b=[10,20,30,40,50,60,70,80,90]
c= a+b
print(c)

直接加号就可以了

这个不会修改a和b

a=[1,2,3,4,5,6,7,8,9]
b=[10,20,30,40,50,60,70,80,90]
c=a.extend(b)
print(a)
print(c)

extend就是在原数组上添加
None就是啥也不是

a=[1,2,3,4,5,6,7,8,9]
b=[10,20,30,40,50,60,70,80,90]
a+=b
print(a)

4.28 元组操作

元组也是数组，只不过元组是在创建元组的时候就设定好了元素，不能修改

a=()
b=tuple()
print(type(a))
print(type(b))

a=(1,2,3)
print(a)

也可以a[1],len(a),a[-1]
a[100]就会报错了
也可以切片
a[1:3]
元组和列表是一样的访问方式，但是元组不能修改元素
元组和元组之间也是可以拼接的
元组不能增加和修改，删除数据
不能a[0]=100这种操作

其实函数在return x,y的时候就是返回了一个元组

4.29 字典创建

就是一个存储键值对的结构

a={}
b = dict()
print(type(a))
print(type(b))

key和value的类型不一定都是一样的

a={'id':1,'name':'zhangsan'}
print(a)

a={'id':1,'name':'zhangsan'
}

4.30 字典查找key

a={'id':1,'name':'zhangsan'
}
print('id' in a)

就是判断某个key在不在字典中
不能判断value的
也可以not in

a={'id':1,'name':'zhangsan'
}
print(a['name'])

注意key可以为整数

a={'id':1,'name':'zhangsan',100:'list'
}
print(a[100])

4.31 字典的新增修改删除

a={'id':1,'name':'zhangsan',
}
a[100]='list'print(a)

这个就是新增了

a={'id':1,'name':'zhangsan',
}
a[100]='list'
a[100]='list2'
print(a)

这样就可以修改了

a={'id':1,'name':'zhangsan',
}
a.pop('name')
print(a)

这样就可以删除了，操作都是针对key来的

4.32 字典遍历

a={'id':1,'name':'zhangsan',
}
for key in a:print(a[key])

字典的for拿到的是key

a={'id':1,'name':'zhangsan',
}
print(a.keys())
print(a.values())

dict_keys可以直接当做列表使用

a={'id':1,'name':'zhangsan',
}
print(a.keys())
print(a.values())
print(a.items())

这是一个列表，列表每个元素是元组

a={'id':1,'name':'zhangsan',
}
for key,value in a.items():print(key,value)

4.33 key的类型

print(hash(0))

这个是计算hash值

print(hash('hello'))

不能对列表进行hash，可以对元组进行hash
不能对字典进行hash

不可变的对象是可以hash的，列表字典是不可hash的

4.34 打开文件

f = open('D:/PythonProject/a.txt','r')

第一个是打开文件路径，第二个表示什么方式打开，有r,w,a，，，a是追加写

print(f)
print(type(f))

f就是一个文件对象，就是句柄

4.35 关闭文件

f.close()

这样就可以关闭了
文件打开完一定要关闭–》关闭系统资源

4.36 写文件

f = open('D:/PythonProject/a.txt','w')
f.write('hello world')
f.close()

r方式打开时不能write的

f = open('D:/PythonProject/a.txt','w')
f.close()

直接w方式打开，会把原来的内容清空

f = open('D:/PythonProject/a.txt','a')
f.write('hello world')
f.close()

a方式打开就不会情况原来的内容了
\n就可以换行了

已经关闭的文件不能写

4.36 读文件

f = open('D:/PythonProject/a.txt','r')
res = f.read(2)
print(res)
f.close()

这个表示读取前面两个字符，但是读的不一样，这个是因为编码问题

f = open('D:/PythonProject/a.txt','r',encoding='utf-8')
res = f.read(2)
print(res)
f.close()

encoding='utf-8’是关键字参数，默认是gpk
指定encoding为utf8
一个汉字就是一个字符
记得a.txt也必须是utf8

f = open('D:/PythonProject/a.txt','r',encoding='utf-8')
for line in f:print(line)
f.close()

这个是按照行来读取了
但是有多的一行是因为print自带换行

f = open('D:/PythonProject/a.txt','r',encoding='utf-8')
for line in f:print(line,end='')
f.close()

end表示末尾啥都不加，默认为换行

f = open('D:/PythonProject/a.txt','r',encoding='utf-8')
lines  = f.readlines()
print(lines)
f.close()

readlines就是一起读完了，然后放在列表中

4.37 上下文管理器

—》自动关闭的东西
自动close

就怕忘记关闭

with open('D:/PythonProject/a.txt','r',encoding='utf-8') as f:print(f.read(2))

这个with就是自动关闭的，就是跳出了with就会自动关闭了，而且open赋值给变量f

总结