python 基础语法

Posted 2020-10-31 xing-chen

python的起源？
解释器和编译器区别？
编译型语言和解释型语言的区别？
第一个python程序
每行只能写一条代码语句
每行代码前边不能加空格
python2.0的解释器不支持中文
python3.0 支持中文
怎样交互式执行python程序? Python python3
python 中怎样表示次方？ **
pycharm的安装？ 直接解压就可以使用，把它移动到opt目录方便其他人使用
0.环境的搭建
1.输出字符串
print("hello haha")
命令后跟执行的py文件来运行脚本
python2
python3
交互模式(命令行输入以下命令会进入交互模式)
ipython2
ipython3
2.注释
单行注释
#
多行注释
‘‘‘
print("hello world")
print("hello world")
print("*", end="")
‘‘‘
3.定义变量（不需要定义类型 Python会自动判断））
score = 100
变量类型
Number（数字）
int 整数， python2 整型区分 int 和 long python3中只有int
float 浮点数，
bool 布尔型
String（字符串）
List（列表）
Tuple（元组）
Sets（集合）
Dictionary（字典）

4.输入语句
high = input("请输入你的身高:")
注意:python3把输入的所有东西当成字符串给变量
python2把你输入的东西当做代码执行如name当做变量
python2中用raw_input("ddd")达到相同效果
5.占位符的使用
age = 18
print("age变量里的值是%d"%age)
name = "东哥"
print("名字是:%s"%name)
6.python2 和python3 的中文处理
python3支持中文
python2中如果注释或者代码中有中文的话那么执行的时候会报错
解决办法：在代码开头加上
#_*_ coding:utf-8 _*_ （推荐）
#coding=utf-8
7.判断语法：
if name<18：
代码1
代码2
pass 代表此处有代码只是暂时空着
else：
代码4
代码5
代码6
注意代码前有四个空格的代码受if--else 节制，
代码6由于没有空格所以无论条件符合与否他都会执行。
8.输入类型转换
age = input()获取用户输入的值都是字符串的如果需要把
它变为其他类型，例如int型，可以这样做
age = input()
age_num=int(age)
age_num = int(input("请输入你的年龄:"))
9.一次输出多个值
print("姓名是:%s, 年龄是:%d,地址是:%s"%(name, age, addr))
10.特殊运算符
5/2=2.5
7//2=3 取商
7%2=1 取余
“ABC”*2
输出：ABCABC
2**3=8 幂

比较运算符
<, >, <=, >=, !=
逻辑运算符
and, or,
vi 文件名 +11 编辑11 行
not 代表条件的否定
if not (a>0 and a<=50):
print("在0到50之间....")
11.if-elif用法
sex = input("请输入你的性别:")
if sex == "男":
print("你是男性,可以留胡子....")
elif sex == "女":
print("你是女性,可以留长头发....")
#elif sex == "中性":
else:
print("你是第3中 性别,想干啥就干啥.....")
12.while用法
while i<=100:
print("%d"%i)#print(i)
i = i+1
13.if-else 的嵌套
#先判断是否有车票
if ticket==1:
print("通过了车票的检测,进入到了车站,接下来要安检了")
#判断刀的长度是否合法
if knifeLenght<=10:
print("通过了安检,进入到了候车厅")
print("马上就要见到TA了,很开心.....")
else:
print("安检没有通过,等待公安处理....")
else:
print("兄弟 你还没有买票了,先去买票 才能进站....")
14.while嵌套
i=1
#用来控制行数（打印矩形）
while i<=5:
#用来控制每一行中的列数
j = 1
while j<=5:
print("*", end="")
#j = j+1#c语言中向让j加上1的方式: j++; ++j; j+=1; j=j+1;
j+=1
print("")
i = i+1
print("*", end="") print语句打印完默认换行，后加end可以让其不换行
15.复合赋值运算符
a+=1------------>j=j+1
a-=1,a*=1,a/=1,a%=1,a//=1
获得一个0-2的随机数
computer = random.randint(0,2)
break用来跳出循环
continue用来跳过本次循环
while循环嵌套中的break的作用范围：只作用于最近的while
16.字符串在内存中的存储方式
一个字节存储最大值255
数字110可以用一个字节存储
“110”必须用四个字节每个字符占一个字节末尾加“\0”python中可以不算
str(110)可以数字转成字符串
len(变量)可以看变量所占的字节数
17.组成字符串的两种方式
一、+号 两边是字符串则组合的是字符串，两边有一个是数字组合的是数字
二、 f = "====%s===="%(a+b)
18.下标和切片
name="abcdefghijk" 字符串中的字母已经被标号了从0开始
name[2]则可以取出c
name[-1]可以取出k
切片(取一片)
name[2:6]会取出cde(包头不包尾)
name[2:-1]从第三个取到倒数第二个
name[2：]取到末尾
name[2:-1:2]跳着取，即最后一个代表步长cegi
name[::-1] 把字符串逆序
19.字符串常见操作
mystr="dajsi AAADFE JFIEIWEJIJojeei "
mystr.回车可以查看到所有字符串操作（交互模式）
mystr.find("AA") 会返回6即第一个字母的下标，找不到返回-1
mystr.rfind("AA") 从后往前找第一个
mystr.index("aa") 找到返回下标，找不到返回异常异常异常！！！
mystr.rindex("aa") 找到返回下标，找不到返回异常异常异常！！！
mystr.count("aa",start=0,end=len(mystr)) 返回字符出现的个数
mystr.replace("a","A",1,) 把字符串中的a替换为A,第三个参数为替换几个此处第一个a被替换
mystr.split(" ") 参数为按什么切，什么都不加默认按空格和/t全切掉
mystr.splitline()按行切割/n
mystr.capitallize() 第一个单词首字母大写
mystr.title() 每个单词首字母大写
mystr.startwith("a"）是不是以什么开头 返回值true或flase
mystr.endwith(".txt") 是不是以什么结尾的
mystr.lower() 转换小写
mystr.upper() 转换大写
mystr.ljust(50)靠左对齐
mystr.rjust(50)靠右对齐
mystr.centet(50)居中对齐
mystr.lstrip（）清除左边空格
mystr.rstrip（）清除右边空格
mystr.strip（）清除左右空格
mystr.partition(“AAA”)从左找AAA分割
mystr.isalpha()是字母返回true
mystr.isdigit()是数字返回true
mystr.isalnum()既有字母又有数字返回true
mystr.isspace()判断是否是纯空格
“=”.jone(liebiao)把列表的元素用=连接
20.列表
定义
name = ["老王","老李","老杜"，3.14]，可以存储多种数据类型
操作（增删改查）
增：name.append("悟空") 在结尾添加
name.insert(0,八戒) 在下标为0的位置添加
name1.extend(name2) 合并两个列表，
name1+name2 合并两个列表，
删：name.pop() 删最后一个元素
name.remove("老李") 根据内容删除,从前往后找只删除一个
del name[3]
改：name[0] = "清晨" 修改指定下标元素
查："老赵" in name 判断老赵是否在name列表里
"老赵" not in name
21.字典
定义：
infor = {"名字":"占山","QQ":"十七","键3":"值3"}
列表里可以嵌套字典
name=[{"名字":"占山"}{"QQ":"十七"}{"名字":"山东"}]
name[“名字”] 取出所有名字
字典操作
增: infor[age1]=18
删: del infor["name"]
改：infor[名字]=“ss”
查：infor["QQ"] 没有报异常
infor.get("QQ") 没有不报异常
22.for-else的应用
for v in V
pass
else
pass
23.列表的extend和append
a=[1,2]
b=[22,11]
a.extend(b)--->[1,2,22,11]
a.append(b)--->[1,2,[22,11]]
24.字典常见操作
info={"名字":"占山","QQ":"十七","键3":"值3"}
len(info) 测得是键值对的长度
python2中
info.keys()获取字典中所有的键，返回的是列表
info.value()获取字典中的所有值，返回值为列表
Python3中返回的是对象
info.keys() 返回值为----->dict_keys([mame,age])
info.items() 获取键和值得元组封装在列表里 列表放到元组里
dict_keys([("mame","la"),("age",12)])
拆包

24.元组
定义：a=(1,2,3)
元组和列表类似但是元组是不可以修改的，但可以使用连接符
type(a)=tuple;
删除元组：
del a
元组的拆包：
a=(1,2,3)
d,b,c = a--->d=1;b=2;c=3
tuple(列表)可以把元组转换为列表
注意;如果只有一个值(1,)才叫元组
25.函数的定义
sublime小技巧选中ctrl+d可以多行编辑ctrl+--> 直接 跳到行尾
定义函数
def 变量名()：
代码一
代码二
函数调用
变量名()
多个函数定义后可以随意调用，与定义顺序无关
定义带参数的函数
def 变量名(a,b)
语句一
语句二
带有范返回值得函数
def 变量名(a,b)
语句一
语句二
c=22
return c
带有多个return返回值的函数
语法无错，但只会返回第一个值其他return不会执行，因为函数结束了
但可以把多个值封装到元组，列表中可以返回。
四种函数：
无参无返回，无参有返回值，有参有返回值，有参数无返回值
函数的嵌套调用
def print_line():
print("-"*50)

def print_5_line():
i = 0
while i<5:
print_line()
i+=1

print_5_line()
26.局部变量和全局变量
局部变量
在函数里定义的变量，只在本函数内起作用，称作局部变量
全局变量
在函数定义或调用之前定义的变量
局部变量与全局变量的区别
#定义一个全局变量,wendu
wendu = 0

def get_wendu():
#如果wendu这个变量已经在全局变量的位置定义了,此时还想在函数中对这个全局变量进行修改的话
#那么 仅仅是 wendu=一个值 这还不够,,,此时wendu这个变量是一个局部变量,仅仅是和全局变量的名字
#相同罢了
#wendu = 33

#使用global用来对一个全局变量的声明,那么这个函数中的wendu=33就不是定义一个局部变量,而是
#对全局变量进行修改
global wendu
wendu = 33

def print_wendu():
print("温度是%d"%wendu)

get_wendu()
print_wendu()
注意：
全局变量必须放在函数调用之前，
全局变量命名建议加前缀避免和局部变量相同
函数文档说明
help(print)可以查看函数文档说明
函数第一行添加如下格式可以添加文档说明
"""显示所有的名片信息"""
列表和字典可以在函数中当做全局变量不用加globle
return 14,13 返回的是元组（14,13）
27.默认参数
def test(a,d,b=22,c=33):
print(a)
print(b)
print(c)
print(d)

test(d=11,a=22,c=44)
test(11,22,33)
不定长参数
def sum_2_nums(a,b,*args):
print("-"*30)
print(a)
print(b)
print(args)

result = a+b
for num in args:
result+=num
print("result=%d"%result)

sum_2_nums(11,22,33,44,55,66,77)
sum_2_nums(11,22,33)
sum_2_nums(11,22)
#sum_2_nums(11)#错误,因为 形参中 至少要2个实参

def test(a,b,c=33,*args,**kwargs):#在定义的时候 *,**用来表示后面的变量有特殊功能
print(a)
print(b)
print(c)
print(args)
print(kwargs)

#test(11,22,33,44,55,66,77,task=99,done=89)
A = (44,55,66)
B = {"name":"laowang","age":18}
test(11,22,33,A,B) 输出和下边一行不一样
test(11,22,33,*A,**B)#在实参中*,**表示对元祖/字典进行拆包
test(name="dd")多余的参数保存到元组中*args,键值对保存到**kwargs中
28.引用
id(变量) 可以得到变量保存的地址
a = 100
b = a 把a的地址给b而不是给a的值这叫引用
注意：如果变量引用丢失，python会自动清理。
29.可变类型，不可变类型
字符串是不可变类型
只有列表和字典可变
可变类型不可以当KEY值原因和Hash算法有关
30.num=[1,2,66,33,55]排序
num.sort() 默认从小到大排序
num.sort(reverse=true)从大到小排序
对字典排序
num.reservice() 逆序infors = [{"name":"laowang","age":10},{"name":"xiaoming","age":20},{"name":"banzhang","age":10}]
infors.sort(key=lambda x:x[‘age‘])
31.匿名函数
test2 = lambda a,b:a+b
result2 = test2(11,22)#调用匿名函数
eval的用法：可以在python3中把输入的东西，由字符串变成其他的函数，正数等。
#python2中的方式
#func_new = input("请输入一个匿名函数:")
#python3中的方式
func_new = input("请输入一个匿名函数:")
func_new = eval(func_new)
32.交换两个变量的方式
a = 4
b = 5
#第1种
#c = 0
#c = a
#a = b
#b = c
#第2种
#a = a+b
#b = a-b
#a = a-b
#第3种(python独有)
a,b = b,a
print("a=%d,b=%d"%(a,b))
33.python中不存在值传递，全是引用
#a = 100
a = [100]
def test(num):
#num+=num# +=表示 num指向谁就对谁进行修改,如果num指向[100],那么就变为[100,100]
#如果num 指向100,因为100是不可变类型,所以不能修改,所以num=num+num
num = num+num#===>[100] + [100] ====>[100,100] 注意只要是num=xxx一定是num指向了一个新的地方
print(num)
test(a)
print(a)
34.文件
写入
f = open("xxx.txt","w")
f.write("hahaha")
f.close()
读取
f = open("xxx.txt","r")
content = f.read()
print(content)
f.close()
f.read(num) 每次读num个字节
f.readline()每次读一行，返回字符串
f.readlines()每次读一行，封装到列表里，返回列表
文件名处理
#test.py -----> test[复件].py
#new_file_name = "[复件]"+old_file_name
position = old_file_name.rfind(".")
new_file_name = old_file_name[:position] + "[复件]" + old_file_name[position:]
35.文件的定位读写

f = open("a.txt","r")
f.seek(a,b)
a表示跳过的字节数 正数往右调，负数往左调，python3不支持负数
b有三个值 0 文件开头
1 文件当前位置
2 文件末尾
import os
os.rename("旧文件名","新文件名")
os.remove("文件名")
os.mkdir()
os.rmdir()
os.getcwd()
os.chdir()
os.listdir()
36.定义一个类
class Cat:
#属性

#方法
def eat(self):
print("猫在吃鱼....")

def drink(self):
print("猫正在喝kele.....")

创建一个对象
tom = Cat()
调用对象方法
tom.eat()
给对象添加属性
tom.name = "汤姆"
tom.age = 40
对象的属性的获取
print("%s的年龄是:%d"%(self.name, self.age))
定义个方法，把上边的语句放入方法中
37.self的用法
#方法
def eat(self):
print("猫在吃鱼....")
定义方法时传入self代表调用对象，类似java中的this
但是self不是关键字可以用其他任何字符替换
38. __init__的用法
#初始化对象
def __init__(self, new_name, new_age):
self.name = new_name
self.age = new_age
lanmao = Cat("蓝猫", 10)
39.创建对象的方法
创建对象
python自动调用init方法
返回对象引用给变量
40.__str__的用法(类似java中的toString())
def __str__(self):
return "%s的年龄是:%d"%(self.name, self.age)
print(tom)
41.隐藏属性
可以在类中不定义属性，而在外边进行属性的添加
42.#私有方法
def __send_msg(self):
print("------正在发送短信------")
43.__del__用法
def __del__(self):
print("-----英雄over------")
#如果在程序结束时,有些对象还存在,那么python解释器会
自动调用它们的__del__方法来完成清理工作
44.测对象引用计数方式
import sys
sys.getrefcount(对象)返回的是引用计数个数
45.继承
#父类
class Animal:
def eat(self):
print("-----吃----")
#子类(在子类名字后加小括号传入父类)
class Cat(Animal):
#扩展父类功能
def catch(self):
print("----抓老鼠----")
#重写父类功能
def eat(self):
print("-----吃啊啊啊啊----")
调用被重写的方法
#第1种调用被重写的父类的方法
#Dog.bark(self)
#第2种
super().bark()
私有方法，私有属性，在继承中的表现
私有的东西不会被子类继承
46.多继承
所有的类都继承object类
#新式类在括号里写上object类，python3推荐
#经典类不用写，但默认继承
class Base(object):
def test(self):
print("----Base")

class A(Base):
def test1(self):
print("-----test1")

class B(Base):
def test2(self):
print("-----test2")
class C(A,B):
pass
注意点：
如果一个类继承了多个有一样方法名的类时
print(C.__mro__)可以查看类的方法调用顺序，如果找到了就停止搜索，
47.类属性和实例属性
类也是一个对象，类属性属于类对象，多个实例对象共享类属性
class Game(object):

#类属性
num = 0

#实例方法
def __init__(self):
#实例属性
self.name = "laowang"

#类方法
@classmethod
def add_num(cls):
cls.num = 100

#静态方法
@staticmethod
def print_menu():
print("----------------------")
print(" 穿越火线V11.1")
print(" 1. 开始游戏")
print(" 2. 结束游戏")
print("----------------------")

game = Game()
#Game.add_num()#可以通过类的名字调用类方法
game.add_num()#还可以通过这个类创建出来的对象 去调用这个类方法
print(Game.num)
#Game.print_menu()#通过类 去调用静态方法
game.print_menu()#通过实例对象 去调用静态方法
修改类属性Game.num=1
区别：类方法和静态方法都要去传入参数
静态方法不传参数
48.__new__的用法
#子类重写了new方法则必须调用父类的new方法，否则创建失败
#
class Dog(object):
def __new__(cls):#cls此时是Dog指向的那个类对象
#print(id(cls))
print("----new方法-----")
return object.__new__(cls)
#print(id(Dog))
xtq = Dog()
49.单例模式
class Dog(object):
__instance = None

def __new__(cls):
if cls.__instance == None:
cls.__instance = object.__new__(cls)
return cls.__instance
else:
#return 上一次创建的对象的引用
return cls.__instance
50. 只初始化一次
class Dog(object):

__instance = None
__init_flag = False

def __new__(cls, name):
if cls.__instance == None:
cls.__instance = object.__new__(cls)
return cls.__instance
else:
#return 上一次创建的对象的引用
return cls.__instance

def __init__(self, name):
if Dog.__init_flag == False:
self.name = name
Dog.__init_flag = True

51.异常处理
#coding=utf-8
try:
num = input("xxx:")
int(num)
#11/0
#open("xxx.txt")
#print(num)
print("-----1----")

except (NameError,FileNotFoundError):
print("捕获多个异常用元组....")
print("如果捕获到异常后做的 处理....")
except Exception as ret:
print("如果用了Exception,那么意味着只要上面的except没有捕获到异常,这个except一定会捕获到")
print(ret)
else:
print("没有异常才会执行的功能")
finally:
print("------无论如何都执行-----")

print("-----2----")

52.抛出出自定义异常
定义异常类
class Networkerror(RuntimeError):
def __init__(self, arg):
self.args = arg
抛出自定义异常
try:
raise Networkerror("Bad hostname")
except Networkerror,e:
print e.args

53.模块
一个具有很多功能的集合,是一个py文件
模块的导入
import random
import xxxxxxxxxxxxxx as ss 给模块取个别名
random.__file__ 会得到该模块存放路径
调用模块内容
random.xxx（）
from sendmsg import test1
test1()
安装模块
sodo pip install pygame
sodo pip3 install pygame
自定义模块魔板
def test1()：
pass
def test1()：
pass
def main():
#测试代码
pass

if __name__==‘__main__‘:
main()
54.__all__的作用
#如果导入这个模块的方式是 from 模块名 import * ,那么仅仅会导入__all__的列表中包含的名字
__all__ = ["test1","Test"]

def test1():
print("----test-1-----")

def test2():
print("----test-2-----")

num = 100

class Test(object):
pass
55.包
把好多py文件放在一个文件夹中，如果在晚间夹中建立一个__init__.py
则python会把它当成一个包处理。
编辑这个文件添加
__all__ = ["aaa"]
aaa模块可以使用
其他模块没在文件中引用不可以使用
56.模块的发布与安装
http://blog.csdn.net/qq_29648129/article/details/74852428
57.给程序传参
import sys
sys.argv是一个接收参数的列表
sys.argv[0] 代表的是程序名
sys.argv[1] 代表的是第一个参数

range(10)返回一个列表0-9
range(10,18)返回一个10-17的列表
range(10,18,3)3代表步伐，即跳着取值
range在py2中有风险，占用大量内存可能不用
py3中没有这个问题，因为py3什么时候用空间什么时候生成给你
58.列表生成式
a = [i for i in range(1,18)]
结果生成一个1到17的列表
第一个i可以替换替换成什么列表元素就是什么
a = [i for i in range(1,18) if i%2=0]
a = [(i,j)for i in range(3) for i in range(3)]
结果 ：[(0,0),(0,1),(1,0),(1,1),(2,0),(2,1)]
59.集合
f={d,k,d,d,}
f.set(a)把a列表转成集合
list(f) 把f转为列表
集合操作 add pop remove ...