python基本语法

文章目录

• 一、print()
• 二、运算
• 三、变量
• 四、循环
• 五、if
• 六、函数
• 七、读写文件
• 八、类
• 九、输入input
• 十、元组与列表
• • 1.列表功能
  • 2.二维列表
• 十一、字典
• 十二、载入模块import
• 十三、错误处理
• 十四、lambda，zip，map
• • 1.lambda
  • 2.zip
  • 3.map
• 十五、深拷贝与浅拷贝
• 十六、pickle模块
• 十七、set函数
• 十八、正则表达式

一、print()

1. 单引号括起来的语句不可以出现单引号，若想出现，需要在单引号前面加上转义字符’’
   如：print(‘I’m a girl.’)是正确的 或者 print(“I’m a girl.”)也正确。

2. 没有double类型

3. print()括号中的不同类型可以用逗号隔开，在显示框中会多出一个空格。

二、运算

1. 3**4 表示3的4次方
2. // 表示取整数部分，如9//4=2

三、变量

1. python的变量不用定义数据类型

四、循环

1. 语法为while a < 5: 或者 while True或Flase : 循环体内的语句必须要左边至少空一个tab

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

输出结果为1到9，以换行隔开

for i in range(9):  #表示9个数，i为0到8
	print(a[i])

输出结果 为0到8，以换行隔开。

 for i in range(1,10,2):
	print(i)

range函数(左闭右开)最后一个数字表示步长h。
会输出结果1，3，5，7，9 中间以换行隔开。

4. continue，break和pass：pass表示空语句，continue和break与c用法相同

五、if

1. 语法1：if a>b>c:
2. 语法2：

if x>y:
	print()
else:
	print()

4. 语法3：

 if x>1:
	print()
elif x<1:
	print()
elif y>1:
	print()
else:
	print()

六、函数

函数定义：

def fun():
	print(“hahhahha”)
	c = a+ b
	Print(‘the c is’,c)

函数调用：

fun(2,5) #或者fun(b=5,a=2)

2. 函数形参可以设定默认值，定义默认值的变量必须连续且在最右面。

3. 函数中可以加 return 表示返回内容。

七、读写文件

1. w写文件：

file = open("mytext.txt","w") #以写的方式 打开文件 并赋给file（file理解为待写的文件类型）
text = "我是好人n我是大好人n我是坏人."
file.write(text) #将text的内容写文件
file.close() #关闭文件

2. a文件里面追加内容：

file = open("mytext.txt","a") #以添加的方式打开文件（file理解为待添加的文件							 		类型）
text_add = "追加内容."
file.write(text_add) #将text_add的内容加到mytext.txt(也可以没有)中
file.close() #关闭文件  

3. r读文件：

file = open('mytext.txt','r') #以读的方式打开文件（file理解为待读的文件类型）
print(file.read()) #文件内容输出到屏幕

八、类

1. 类的基本用法

class person:
    name = "裴鑫达"
    age = 20
    sex = '男'
    def add(self, x, y): #函数的第一个形参self不能少
        print(self.name) #在类内写属性，必须是self.的格式
        aa = x + y
        print(aa)
    def jian(self, x, y):
        aa = x - y
        print(aa)
    def cheng(self, x, y):
        aa = x * y
        print(aa)
a = person() #实例化对象
a.add(5,15) #调用类内的函数
print(a.name) #输出类内的属性

2. 类内的初始化函数

class person:
    def __init__(self, name, age, sex='man'):
        self.name = name
        self.age = age
        self.sex = sex
a = person('john',19) #初始化类内属性

九、输入input

1. 输入函数基本用法

a = input('write a number:')
if(a == '1'):
    print(100)
elif(a == '2'):
    print(200)
else:
	print('no condition!')

input函数的返回类型是string，所以输入的如果不是字符串都会强制转换为字符串再发送给编译器。（输入’1’时会输出no condition!）

十、元组与列表

1. 元组为只读类型，表示单个元组时如下

a_tuple1 = 2, #不是a = (2)

2. 元组可加可乘

a_tuple = (1,2,3)
b_tuple = (2,3,4)
print(a_tuple+b_tuple) #(1, 2, 3, 2, 3, 4)
print(a_tuple*2) #(1, 2, 3, 1, 2, 3)

3. 列表的两种遍历方法

a_list = [4,5,6,7]
for i in a_list:
    print(i)
    #或者
for i in range(len(a_list)):
    print(a_list[i])

1.列表功能

#a[-1] 表示列表的最后一位 , a[-2] 表示列表的倒数第二位 
a = [20,5,89,1,3,89,2]
a.append(0)      #在列表后追加一个元素0
a.insert(1,45)   #a[1]变为45,其他元素后移
a.remove(89)     #在列表中删除索引最小的为89的元素
a.sort()         #使列表a从小到大排序
a.sort(reverse = True)  #从大到小排序

print(a.count(89))     #输出89在列表中的个数
print(a.index(89))     #输出列表中索引最小的为89的元素
#左闭右开
print(a[1:3]) 表示输出从a[1]到a[2] 
print(a[:3]) 表示输出从第一位到a[2]
print(a[2:]) 表示输出从a[2]到最后一位

2.二维列表

a = [[1,2,3],[4,5,6],[7,8,9]]   #二维列表定义

十一、字典

字典中的索引表示的是 : 前的部分

d1 = {'apple':1,'peach':2}  #创建字典的d1
print(d1)                   #打印字典d1
print(d1['apple'])          #输出d1字典apple:后面的值
del d1['apple']             #删除d1字典中apple的部分
d1['water'] = 33            #d1字典中添加元素

d2 = {1:'a',2:'b'}          #创建字典d2
print(d2[1])                #输出d2字典1:后面的值

#字典嵌套
d3 = {1:100,2:200,3:{10:1000,20:2000}}    
print(d3[3][20])            #2000

十二、载入模块import

1. 在最开始写：import time 表示载入time模块，表示可以使用time库中的py文件。 使用格式为：time.localtime()等等
2. 在最开始写：import time as t ，表示t可代替time，适用于模块名较长的情况 。
3. 使用time模块的某一个功能可以在最开始写：
   from time import localtime as loc或者import time.localtime as loc
4. 使用time模块的全部功能：在最开始写：from time import *
   在使用time模块的内容时不用加time.了
5. 也可以自己写模块（.py的格式），但是必须要放在同一路径才可以import，或者将要载入的模块放在site-packages中。（外部下载的模块都放在这里）

十三、错误处理

#try语句体中写可能会出现错误的语句
try:
    file = open('ee','r')
#as e可写可不写,若写了,然后print(e),则输出具体错误内容
except Exception as e: 
    print(e)
#若try体里的语句正确，则执行此块的内容
else:
    pass

十四、lambda，zip，map 1.lambda

它的作用是用来实现比较简单的函数功能，如方程、加减乘除计算等等。

def fun1(x,y):
    return (x+y)
print(fun1(5,6))
#或者
fun2 = lambda x,y:x+y
print(fun2(5,6))

两者功能一样，都会输出11。

2.zip

zip的作用是将两个列表或者元组以元组的形式一一对应起来，可以用循环的方式输出，也可以用list或者tuple的形式输出，但是不可以print(zip(a,b))。

a = [1,2,3]
b = [10,20,30]
#遍历zip(a,b)，zip(a,b)是将两个列表一一对应
for i,j in zip(a,b):
    print(i*2,j/2)      #2 5.0n4 10.0n6 15.0
    
print(list(zip(a,b)))   #[(1, 10), (2, 20), (3, 30)]
print(tuple(zip(a,b)))  #((1, 10), (2, 20), (3, 30))

3.map

map是将功能和参数合起来的一个运算，可以用循环的方式输出，也可以用list或者tuple的形式输出，但是不可以print(map())
map的参数一定要是可以遍历的，所以int类型不可以作为参数。

fun = lambda x,y:x*y #功能为一一对应相乘
#循环遍历输出
for i in map(fun,[1,3],[2,4]):
    print(i)     # 2n12

print(list(map(fun,[1,3],[2,4]))) #以列表的形式输出，结果为[2,12]
print(tuple(map(fun,[1,3],[2,4])))#以元组的形式输出，结果为(2,12)

十五、深拷贝与浅拷贝

2，3，4点在使用前，要import copy

1. 如果是b = a，表示b和a都占用同一块内存空间，为浅拷贝。
2. 如果a是单层列表，那么执行b = copy.copy(a)，表示b和a占用不同空间（改变一个不会影响另外一个），为深拷贝
3. 如果a是双层列表，那么执行b = copy.copy(a)，copy只会拷贝一层，为外层（父对象），所以说外层为深拷贝（外层占用不同内存空间），而里层为浅拷贝（占用相同内存空间）。
4. 对于b = copy.deepcopy(a)来说，不管里层外层都占用不同内存空间，为深拷贝。

十六、pickle模块

它的作用是可以保存代码中的变量的内容在电脑的同一目录上，保存形式为.pickle，然后可以在另外一个文件中进行复原。代码示例如下：

import pickle
a_dict = {1:10,2:20,3:30}
file = open('test.pickle','wb') #以wb（写）的形式打开.pickle文件并赋给file（file是个文件类型）
pickle.dump(a_dict,file) #利用pickle模块的dump功能，将前者字典的值放到后者file文件里
file.close()  #关闭文件

import pickle
file = open('test.pickle','rb') #以rb（读）的形式打开.pickle文件并赋给file（file是个文件						   类型）
a_dict2 = pickle.load(file) #利用pickle模块的load功能，将file中的内容load下来给a_dict2
file.close() #关闭文件
print(a_dict2) #打印字典的值

十七、set函数

作用是挑出不一样的元素，以花括号的形式打印出来。
set()函数中只能传 一个列表 或者 一个字符串。
aa.add()功能 不可以添加列表 ，只可以添加单个列表元素。 代码示例：

a = ['a','b','c','c','d','d','d']
print(set(a))       #输出乱序的字典形式：{'a', 'c', 'd', 'b'}
b = "hello world!"
print(set(b))       #{'w', 'r', ' ', '!', 'l', 'o', 'h', 'e', 'd'}

aa = set(a)
aa.add('x')    #添加'x'
print(aa)      #{'d', 'c', 'x', 'a', 'b'}
aa.add('a')    #添加本来就有的字符'a'
print(aa)      #{'d', 'c', 'x', 'a', 'b'}

aa.remove('x')    #去除'x'
print(aa)         #{'d', 'c', 'a', 'b'}
#aa.remove('y')   #会报错，因为没有'y'
aa.discard('y')   #虽然没有'y',但是不会报错
print(aa)         #{'d', 'c', 'a', 'b'}
aa.clear()        #清除列表所有内容
print(set(a))         #set()

十八、正则表达式

匹配

import re
print(re.search(r"r[ua]ns","dog runs cat")) #

compile(相当于分成两步)

import re
a_compile = re.compile(r"r[ua]ns")
print(a_compile.search("dog runs cat.")) #

匹配所有

import re
print(re.findall(r"r[ua]n","run ran ren")) #['run', 'ran']  代码逗号前的为正则表达式

替换

import re
print(re.sub(r"r[au]ns","catches","dog runs cat"))   #dog catches cat

分裂

import re
print(re.split(r"[,;.]","a;b,c.d"))  #['a', 'b', 'c', 'd']