第一章 基础知识
2022-01-04 本文已影响0人
喜忧参半
python2.X
1.数字和表达式
>>> print "hello world!"
hello world!
计算器
>>> 21321+213123 //加法
234444
>>> 1.0/2.5 //浮点数除法
0.4
>>> 12%10 //取余
2
>>> 26//5 //整除 双斜杠整除
5
>>> 2.75%0.5
0.25
幂运算符
>>> 2**3 //两个**代表求幂运算
8
>>> (-3)**3 //负数要带括号
-27
>>> pow(2,3) //也可用pow函数
8
十六进制与八进制
>>> 0xAF //十六进制
175
>>> 011 //八进制
9
变量
>>> x=3 //变量名可以包括字母、数字、下划线，但不能数字开头
>>> x*2
6
语句
>>> 2*2
4
>>> print 2**2 //打印输出语句 py3中print是函数，意味着要加括号
//>>>print (2*2) python3.x
4
获取输入 input("XXX")
>>> input("The meaning of life:")
The meaning of life:42
42
>>> x=input("x:")
x:21
>>> y=input("y:")
y:29
>>> print x+y
50
函数
>>> 10+pow(2,3*5)/3.0 //pow表示指数函数
10932.666666666666
>>> abs(-10) //abs表示绝对值函数
10
>>> round(4.0/2.0) //把浮点数四舍五入取整
2.0
>>>
模块
>>> import math //导入math模块
>>> math.floor(32.9) //math模块中的floor函数
32.0 //取整
>>> int(math.floor(32.9)) //转化float为int类型
32
>>> from math import sqrt //导入math模块中的sqrt函数
>>> sqrt(16) //sqrt表示开方
4.0
cmath与复数
>>> from math import sqrt
>>> sqrt(-1)
nan
>>> import cmath // cmath= complex math 复数模块
>>> cmath.sqrt(-1)
1j //j结尾表虚数
---------------------------复数运算-------------------------
>>> (1+3j)*(9+4j)
(-3+31j)
python3.X
进制转换：
| 二进制 | 八进制 | 十六进制 |
|---|---|---|
| bin | oct | hex |
>>> 0b10 //二进制
2
>>> 0o11 //八进制
9
>>> 0x12 //十六进制
18
>>> bin(10) //转为2进制
'0b1010'
>>> bin(0o16)
'0b1110'
>>> int(0o77) //转为10进制
63
>>> hex(0b111) //转为16进制
'0x7'
>>> oct(0x77) //转为8进制
'0o167'
>>>
Number
type(True) //查看数据类型
bool 类型 //True False 表示真假
complex //复数
字符串
可以用单引号，双引号，三引号来表示
>>> 'hello world!'
'hello world!'
>>> "hello woorld let's go"
"hello woorld let's go"
>>> 'let\'s go' // 转义符'\'
"let's go"
用于换行符 可以用三引号
>>> '''
hello world
i love you
'''
'\nhello world\ni love you\n'
>>> """
if you love me
please tell me
"""
'\nif you love me\nplease tell me\n
>>> '''
hello world\nhello hello
'''
'\nhello world\nhello hello\n'
>>> print ('''
hello world\nhello hello
''')
hello world
hello hello
>>>"""
'\nhello world\nhello world\n""\n"\n'
>>> """hello world
hello world"""
'hello world\nhello world'
>>> 'hello\
asd asd '
'helloasd asd '
>>>
转义符
\r、\n
>>> print ("hello \\n world")
hello \n world
>>> 'let \'s go'
"let 's go"
>>> print ('c:\\AppData\\sad\\asd')
c:\AppData\sad\asd
>>> print (r'c:\AppData\sad\asd')
c:\AppData\sad\asd
字符串运算
>>> 'hello'+'world'
'helloworld'
>>> "bye"*2 //数乘字符串
'byebye'
>>> "hello world"[3]
'l'
>>> "hello world"[1]//
'e'
>>> "hello world"[-1] //从末尾往前数n次
'd'
>>> "hello world"[0:5] //从第一个到第5个
'hello'
>>> "hello world"[0:-1] //从第一个到最后一个
'hello worl'
>>> "hello world"[6:] //从第六个到末尾
'world'
>>> "hello python java c# javascript php ruby"[6:] //从顺数第六个到末尾
'python java c# javascript php ruby'
>>> "hello python java c# javascript php ruby"[-5:] //从倒数第五个到末尾
' ruby'
>>> r'C:\Windows'
'C:\\Windows'
>>> R'C:\Windows'
'C:\\Windows'
>>>
python的基本数据结构
>>> type([1,2,3,4,5]) //组概念
<class 'list'>
>>> ["helo","world",1,9,True,False]
['helo', 'world', 1, 9, True, False]
>>> [[1,2],[3,4],[True,False]]
[[1, 2], [3, 4], [True, False]]
>>>
列表： //中括号表示列表list
>>> type([1,2,3])
<class 'list'>
>>> type([1,2,3,[]])
<class 'list'>
元组：
>>> (1,2,3,4,5) //小括号表示元组tuple
(1, 2, 3, 4, 5)
>>> (1,'-1',True)
(1, '-1', True)
>>> (1,2,3,4)[0]
1
>>> (1,2,3,4)[0:2]
(1, 2)
>>> (1,2,3)+(4,5,6)
(1, 2, 3, 4, 5, 6)
>>> (1,2,3)*3
(1, 2, 3, 1, 2, 3, 1, 2, 3)
序列
>>> 'hello world'[2]
'l'
>>> [1,2,3][2]
3
>>> [1,2,3,4,5][0:3] //称为切片
[1, 2, 3]
>>> [1,2,3,4,5][-1:]
[5]
>>> "hello world"[0:8:2] //切两片
'hlow'
--- in 与 not in-------------
>>> 3 in [1,2,3,4,5,6]
True
>>> 7 in [1,2,3,4,5,6]
False
>>> 7 not in [1,2,3,4,5,6]
True
>>>
字符串：
>>> len([1,2,3,4,5,6])
6
>>> max([1,2,3,4,5,6])
6
>>> min([1,2,3,4,5,6])
1
>>> max('hello world') //按ascll码比较
'w'
>>> min('hello world')
' '
>>> min('helloworld')
'd'
>>> ord('w') //求ascll码
119
>>> ord('d')
100
集合 set
>>> {1,2,3,4,5,6,7}
{1, 2, 3, 4, 5, 6, 7}
>>> {1,2,2,2,3,4,3,3,4}
{1, 2, 3, 4}
>>> len({1,2,3,3,3,4,2,3})
4
>>> 1 in {1,2,3,4}
True
>>> 1 not in {1,2,3,4,5}
False
>>> [1,2,3][0]
1
>>> {1,2,3,4,5,6}-{3,4} //求差集
{1, 2, 5, 6}
>>> {1,2,3,4,5,6}&{3,4} //求交集
{3, 4}
>>> {1,2,3,4,5,6}|{3,4,7} //求并集
{1, 2, 3, 4, 5, 6, 7}
>>> set() //空的集合
set()
>>> len(set())
0
>>>
字典 dict
字典数据类型中有Key和Value。
字典可以由很多key和value组成
是集合类型(set)
>> {1:1,2:2,3:3}
{1: 1, 2: 2, 3: 3}
>>> type({1:1,2:2,3:3})
<class 'dict'>
>>> {'Q':'新月打击','W':'苍白之瀑','E':'月之降临','R':'月神冲刺'}
{'Q': '新月打击', 'W': '苍白之瀑', 'E': '月之降临', 'R': '月神冲刺'}
>>> {'Q': '新月打击', 'W': '苍白之瀑', 'E': '月之降临', 'R': '月神冲刺'}['Q']
'新月打击'
>>> {'Q': '新月打击', 'Q': '苍白之瀑', 'E': '月之降临', 'R': '月神冲刺'}
{'Q': '苍白之瀑', 'E': '月之降临', 'R': '月神冲刺'}
>>> {1: '新月打击', '1': '苍白之瀑', 'E': '月之降临', 'R': '月神冲刺'}['R']
'月神冲刺'
>>> {1: '新月打击', '1': '苍白之瀑', 'E': '月之降临', 'R': '月神冲刺'}
{1: '新月打击', '1': '苍白之瀑', 'E': '月之降临', 'R': '月神冲刺'}
>>> {1: '新月打击', '1': '苍白之瀑', 'E': '{1,1}', 'R': '月神冲刺'}
{1: '新月打击', '1': '苍白之瀑', 'E': '{1,1}', 'R': '月神冲刺'}
>>> a={1: '新月打击', '1': '苍白之瀑', 'E': '{1,1}', 'R': '月神冲刺'}
>>> type(a)
<class 'dict'>
>>>
空字典：
>>> type({})
<class 'dict'>
>>> {}
{}
小结：
image.png
变量
变量名区分大小写，不可使用保留关键字。
a=[1,2,3,4,5,6]
>>> b=[1,2,3]
>>> a*3+b
[1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3]
值类型和引用类型（指针类型）
int 、str、tuple 值类型 不可改变
list set dict 引用类型，可改变
>>> a=[1,2,3]
>>> hex(id(a))
'0x1b030d4eec0'
>>> a=(1,2,3)
>>> b=[1,2,3]
>>> b.append(4) //追加一个元素
>>> print(b)
[1, 2, 3, 4]
>>>
元组的访问
>>> a=(1,2,3,[1,2,4])
>>> a[2
]
3
>>> a[3][2]
4
>>> a=(1,2,3,[1,2['a','b','c']])
Traceback (most recent call last):
File "<pyshell#53>", line 1, in <module>
a=(1,2,3,[1,2['a','b','c']])
TypeError: 'int' object is not subscriptable
>>> a=(1,2,3,[1,2,['a','b','c']])
>>> a[3][2][1]
'b'
>>>
>>> a=(1,2,3,[1,2,['a','b','c']])
>>> a[3][2][1]
'b'
>>> a[3][2]='4' //这是对列表进行操作，而不是操作元组
>>> print(a)
(1, 2, 3, [1, 2, '4'])
>>>
运算符
关系运算符
>>> 'abc'<'abd'
True
>>> [1,2,3]<[1,2,4] //从第一个元素开始比较
True
>>> (1,2,3)<(0,2,1)
False
>>>
逻辑运算符 and表示且 or 表示或 not表示非
>>> True and True
True
>>> False or False
False
>>> not False
True
>>> 'a' and 'b' //因此返回第二个真返回b
'b' //要判断‘a’是真，'b'也是真，才返回真
>>> 'a' or 'b' //读到'a'已经真，故直接返回'a'
'a' //要判断'a'和‘b’中有一个是真，就返回
>>> not 'a'
False
>>> not 'b'
False
成员运算符
>>> a= 1
>>> a in[1,2,3,4,5] //列表
True
>>> b=6
>>> b-3 not in[1,2,3,4,5]
False
>>> b='h' //字符串
>>> b in 'helol'
True
>>> b not in(1,2,3,4) //元组
True
>>> b = 'c'
>>> b in {'c':1} //字典
True
>>>
身份运算符
>>> a=1
>>> b=1
>>> a is b
True
>>> a=1
>>> b=1.0
>>> a == b // == 比较的是a和b的值
True
>>> a is b //is 比较的是内存地址是否同
False
python中一切都是对象
对象的三大特征：身份id、值value、类型type
>>> a
{1, 2, 3}
>>> type(a)
<class 'set'>
>>> type(a)==str
False
>>> isinstance(a,str)
False
>>> isinstance(a,set) // isinstance判断类型
True
>>> isinstance(a,(int,str,float))
False
>>>
type()和isinstance的区别：
type()不能判断变量的子类型，而isinstance可以判断类型的子类型。
比如isinstance可以判断a是元组(int,str,float)中的一种类型。
位运算符
| 符号 | 名称 | 操作数 |
|---|---|---|
| & | 按位与 | a&b 11才1 |
| | | 按位或 | a|b 遇1则1 |
| ^ | 按位异或 | a^b 遇0则0 |
| ~ | 按位取反 | ~a 遇1则0 |
| << | 左移 | a<<2 |
| >> | 右移 | a>>2 |
>>> a=2
>>> b=3
>>> a&b
2
>>> a=2
>>> b=3
>>> a|b
3
>>>
if 语句
mood = True
if mood :
print('go to left')
# print('back away')
#print ('back away')
else:
print('go to right')
# if code:
# pass
# else:
# pass
#if-else是一个完整结构体
if condition1:
pass
if condiiton2:
pass
#两个if是两个结构体，变量作用域不同
for循环
for主要用来遍历/循环 序列或者集合、字典
a = [['apple','orange','banana','grape'],(1,2,3)]
for x in a:
for y in x:
if y == 'orange':
break
print(y)
else:
print('fruit is gone')
---------------------------------------------------------
a = [ 1,2,3]
for x in a: for x in a:
if x == 2: if x ==2 :
break continue
print(x) print(x)
break直接退出循环，continue进入下一次循环
range函数
a = [1,2,3,4,5,6,7,8]
for i in range(0,len(a),2): //前两个参数是头和尾，最后一个参数是间隔
print(a[i],end=' | ')
//for i in range(len(a),0,-2):从尾到头按2递减
b =a[0:len(a):2] //按2递增
print(b)
1 | 3 | 5 | 7 | [1, 3, 5, 7]
最大递归层数
def funcnmae(parameter_list):
pass
#实现相加 实现print
import sys
sys.setrecursionlimit(999)
#setrecursionlimit 最大递归层数
def add(x,y):
result = x + y
return result
def print12(code):
print12(code)
print('python')
几种简易赋值
a,b,c = 1,2,3
d = 1,2,3
print(type(d))
a,b,c = d
print(a,b,c)
a = 1 b = 1 c = 1
a=b=c=1
print(a,b,c)
python类
类变量
# 面向对象 类=面向对象
# 类最基本的作用：封装代码
class Student():
# 一个班级里所有学生的总数sum
do = 0
sum = 0
name = 'phato' #类变量
age = 0
实例变量
实例方法中的变量就是实例变量
def __init__(self,name, age) -> None:
#初始化对象的属性
self.__score = 0
self.name = name #实例变量
self.age = age #self 是调用当前方法的对象
self.__class__.sum += 1
实例方法（构造函数） _init_(self)
#构造函数 '类变量是与类相关，实例变量是与对象相关
实例方法
def __init__(self,name, age) -> None: ##构造函数/实例方法
#初始化对象的属性
self.__score = 0
self.name = name #实例变量
self.age = age #self 是调用当前方法的对象
self.__class__.sum += 1
print('当前班级的学生人数为:'+ str(Student.sum))
#在实例方法中访问类变量的两种方式
print(self.__class__.sum)
#self.__class_ 在实例方法中访问类变量
类方法
@classmethod #类方法
def puls_do(cls): #cls 是class简写 表示类本身
cls.do += 1
print(str(cls.do)+'人做了homework')
类的内部调用
def do_homework(self):
self.do_english_homework() #类的内部调用
self.__class__.do += 1
print(str(self.__class__.do)+'人做了homework')
def do_english_homework(self):
print('English homework')
类变量do在类的do_homework方法中调用do_english_homework方法
静态方法
@staticmethod ##静态方法
def add(x,y):
print('This is static method')
def marking(self,__score):
if __score < 0 :
return '分数不可为负数'
self.__score = __score
print(self.name + '同学本次得分为:'+ str(self.__score))
方法和函数的区别
方法：设计层面
函数：面向过程 过程式
类中的变量，称为数据成员
通常将方法放在一个类A，实例化放在一个类B 最好分开写。不要在一个类中又写方法又实例化。
通胀一个文件中最好只写一个类。一类一文件
实例化或者调用各种方法
实例化Student对象
from c1 import Student #导入c1文件中Student类
def __init__(self,name, age) -> None: #Student类的构造函数
student1 = Student('coco',17) #实例化Student对象student1
调用Student类中的puls_do类方法
@classmethod #类方法
def puls_do(cls):
cls.do += 1 ##使用类变量do时，需要加上cls.的
print(str(cls.do)+'人做了homework')
Student.puls_do()# 调用puls_do方法
调用私有方法__marking()
def __marking(self,__score):##私有方法__marking(self)
if __score < 0 : ##__socre私有变量
return '分数不可为负数'
self.__score = __score
print(self.name + '同学本次得分为:'+ str(self.__score))
result = student1.__marking(90)
print(result)
student1.__score = -1
print(student1.__score)
print(student2._Student__score)
python包文件：_init_.py
封装与继承
from j2 import Human
class Student(Human):##继承父类Human
#sum = 0
def __init__(self,college,name,age) -> None:#构造函数
self.college = college
Human.__init__(self,name,age)# 调用父类的构造函数
super(Student,self).__init__(name,age)#调用父类方法2
当父类与子类都有相同的方法do_homework时，子类的优先级更高，调用子类的同名方法do_homework.
通过类调用构造方法时，需要写入self参数，此时self代表父类中的参数。
python支持多继承，因此可以使用关键字super(子类,self)调用父类方法，super关键字所代表的父类，为子类student所继承的父类。
