学习Python的基本的数值类型、数据结构以及语法等知识
介绍数值相关类型
标准整型与长整型的定义
以下对象的布尔值为False，其余基本上为True
None
False
0
0L
0.0
0.0+0.0j
''
[>]
()
{}介绍双精度浮点数
介绍复数
介绍十进制浮点型
介绍如何进行类型转换
ceil(x) #向上取整
floor(x) #向下取整
fabs(x) #返回绝对值
factorial(x) #返回阶乘
hypot(x,y) #计算直角三角形斜边长
sqrt(xx+yy) #计算平方根
pow(x,y) #返回x的y次幂
sqrt(x) #返回x的平方根
log(x) #返回x的以e为底的对数
log10(x) #返回x以10为底的对数
trunc(x) #截断小树部分，返回整数
isnan(x) #检查是否为非数字
degree(x) #将弧度转换为角度
radians(x) #将角度转化为弧度介绍常见的几种数据结构
定义字符串如下所示
str1 = '这是单引号包裹起来的字符串'
str2 = "这是双引号包裹起来的字符串"如果想要获取字符串中某一个字符，可以进行访问，之后截取，如下所示
str1 = '这是单引号包裹起来的字符串'
str2 = "这是双引号包裹起来的字符串"
print("str1[0]: ", str1[0]) # 这
print("str2[0:4]: ", str2[0:4]) # 这是双引号在字符串中也会涉及到操作符，具体如下所示
+ 连接连个字符串 Hello + World = Hello World
* 对字符或字符串进行倍数复制 Hello*2 = HelloHello
[] 对字符串进行字符截取 a=Hello a[1]=e
[:] 截取指定范围内容的字符内容 a=Hello a[0:2]=Hel
in 判断字符或字符串是否在某个指定内容里面 H in Hello -> 1
not in 判断字符或字符串是否不在某个指定内容里面 A not in Hello -> 1
r/R 输出原始字符 print(r'\n') -> \n列表为类似数组，定义如下所示
list1 = ['a', 'b', 'c', 'd']
list2 = ['china', 'usa', 'uk', 'sg']
list3 = [1, 2, 3, 4, 5]对列表进行访问
print(list1[0:2]) # ['a', 'b']
print(list2[1]) # usa
print(list3[0:4]) # [1, 2, 3, 4]
print(list1[-2]) # c
print(list2[1:]) # ['usa', 'uk', 'sg']对列表进行操作
# 更新
list1[2]=5
print(list1[2]) # 5
# 删除
del(list1[2])
print(list1) # ['a', 'b', 'd']
# 操作符
list4 = list1 + list2
print(list4) # ['a', 'b', 'd', 'china', 'usa', 'uk', 'sg']
# 复制
list5 = ['hello']*4
print(list5) # ['hello', 'hello', 'hello', 'hello']与列表类似，可以进行相同的操作等，但是元组的元素不能修改，使用小括号，定义如下所示
tup0 = () #空元组
tup1 = ('1', '2', '3', '4', '5')
tup2 = ('a', 'b', 'c', 'd')
tup3 = "china", "usa", "uk", "sg"
tup4 = (50,) #一个元素时需要在后添加,字典是键值对形式定义如下所示，具有的特性为不允许同一个键出现两次
dict1 = {"name":"bob","country":"usa"}
print(dict1) # {'name': 'bob', 'country': 'usa'}
print(dict1["name"]) # bob
print(dict1["country"]) # usa对字典内容进行处理
# 修改
dict1["country"] = "uk"
print(dict1["country"]) # uk
# 删除
del dict1["country"] # 单一
dict1.clear() #全部清空
del dict1 # 删除词典与数学上的集合概念一致，使用示例如下所示
s1 = set('abcdde')
s2 = set([1,2,3,4,5])
# 对集合操作
s.add()
s.update()
s.remove()list1 = [1,2,3,4,5]
for i in range(len(list1)+1):
if i == 0:
continue
else:
print(list1[-i])str1 = "abcd1234efgh6666"
if "6666" in str1:
str1 = str1.replace("6666","9999")
print(str1)本节主要讲IF-ELSE、FOR以及WHILE等相关内容
具体语法定义如下所示
if xxxx:
code
elif xxxx:
code
elif xxxx:
code
else:
code
if xxxx:
code
else:
code主要用于循环，具体使用如下所示
for i in range(num):
code
list1 = ['cat', 'dog', 'pig']
for ani in list1:
code与其他语言一样
while (i < 9):
code
i += 1
while True:
code在循环中常使用的范围序列
range(start,end,step)XRANGE与RANGE的使用方法一致，但是有区别的是XRANGE不生成完整的列表，效率更高，并且只有在for循环中使用才有意义
break与continue与其他语言使用一直，pass则是在一些循环或条件分支中不做动作时用于进行补充的，如下所示代码
ips = [
"127.0.0.1",
"192.168.1.1",
"192.168.1.2",
"192.168.1.3",
"192.168.1.4",
"192.168.1.5",
"0.0.0.0"
]
for ip in ips:
if ip == "0.0.0.0":
print("1")
pass
elif ip == "127.0.0.1":
print("2")
break
elif ip == "192.168.1.1":
print("3")
continue
else:
print(ip)
# 运行结果最终输出2，结束整个循环for i in range(4):
name = input("Username: ")
passwd = input("Passwd: ")
if name == "seven" and passwd == "123":
print(f"[+] Login Successful, Welcome {name}!")
break
elif name != "seven":
print(f"[!] Not Found {name}")
continue
elif name == "seven" and passwd != "123":
print(f"[!] {name}'s Password Error!")
continue
else:
print("Hacking!")
passsum_f = 0
sum_z = 0
n = 100
while (n>=2):
if n % 2 == 0:
sum_z += n
else:
sum_f += n
n -= 1
sum_all = sum_z - sum_f
print(sum_all)函数则类似数学理论中的公式，提出或者写出一个函数，只要输入所需要的参数则可以进行复用
在Python中通过关键字def来进行函数的定义，使用样例如下所示
def funcExample(x,y):
code with x,y
funcExample(1,2) #调用函数函数中的参数称为形参，我们提供给函数的称为实参，如下所示代码
def scanPort(ip,ports):
if ip != None and ports != None:
print(f"[+] Begin Scan {ip}'s Ports!")
else:
print("[!] Error!")
scanPort("127.0.0.1","3306") # 127.0.0.1与3306为实参，ip和ports为形参如果在函数内部定义了一个x变量，在函数外依然可以继续定义x变量，但是两者作用域不同，前者在函数内部，后者全局可用，如示例代码
def scanPort(ip,ports):
count = 0
if ip != None and ports != None:
print(f"[+] Begin Scan {ip}'s Ports!")
else:
print("[!] Error!")
count = 0
scanPort("127.0.0.1","3306") # 127.0.0.1与3306为实参，ip和ports为形参在这里的count两者不影响，如果想要在函数内为函数外的变量进行赋值，那么可以在函数内部进行定义global count，即可实现
在函数定义时，我们可以针对一些参数做默认定义，但是用户依然可以传递参数，如下所示
def testFunc(x,y=1):
code
testFunc(1) # 使用默认
testFunc(1,2) # 传入参数并且在使用默认参数时，只有末尾的是可以使用的，如果上述变成a=1,y这是不行的
当参数较多时，可以通过名字来进行传参数，如下所示
def testFunc(a,b=5,c=6):
pass
testFunc(3,7) # a=3,b=7
testFunc(25,c=26) # a=25,c=26
testFunc(c=100,a=99) # c=100,a=99与其他语言一样，用return来返回值，如下所示
def findMax(x,y):
if x > y:
return x
elif x < y:
return y
else:
print("Eq")
print(findMax(3,5)) # 5def loginCheck(username,passwd):
if username == "seven" and passwd == "123":
print(f"[+] Login Successful, Welcome {username}!")
return True
elif username != "seven":
print(f"[!] Not Found {username}!")
return False
elif username == "seven" and passwd != "123":
print(f"[!] {username}'s Password Error!")
return False
name = input("Username: ")
passwd = input("Password: ")
loginCheck(username=name,passwd=passwd)def findString(oriStr,findStr):
if findStr in oriStr:
print(f"[+] Found {findStr} in {oriStr}!")
else:
print(f"[!] Not Found {findStr} in {oriStr}!")
findString("1234abcd6666","6666")模块类似函数，实现后也可以进行复用，区别于函数的是，函数只能在一个代码文件里面复用，而模块可以在不同应用中使用，对于模块的导入使用如下所示
import module_name
import module_name as new_name
from module_name import sub_module
module_name.xxxx
new_name.xxxx创建模块很简单，首先在这里我们以前面的代码为例子，建立一个登录校验的模块，代码如下所示
def loginCheck(username,passwd):
if username == "seven" and passwd == "123":
print(f"[+] Login Successful, Welcome {username}!")
return True
elif username != "seven":
print(f"[!] Not Found {username}!")
return False
elif username == "seven" and passwd != "123":
print(f"[!] {username}'s Password Error!")
return False将代码命名为login.py，之后在其他文件中导入并使用，代码如下所示
from login import loginCheck
loginCheck("admin","123")当我们在程序运行时，可能参数、调用或者其他的方法使用不对，会造成程序异常，这时候我们就需要捕获并针对异常进行进一步的处理，以保证程序的正常运行
在程序中，把可能出现错误的部分放在try块中，之后从except中捕获和处理所有的错误以及异常，如下所示
while True:
try:
n = int(input("Number: "))
break
except ValueError as e:
print("Not Number",e)
print("Good")执行上面的代码后有如下两种输出，如下所示
Number: a
Not Number invalid literal for int() with base 10: 'a'
Number: 1
Good当输入不属于数字类型时，则会捕获并处理和输出错误
在一些大的项目工程中，一段代码可能出现多种异常，此时就需要多异常捕获来进行处理，如下代码所示
import sys
try:
f = open('requirements.txt')
s = f.readline()
i = int(s.strip())
except IOError as e:
print("I/O error",e)
except ValueError:
print("No valid")
except:
print("Unexpected error: ", sys.exc_info()[0])
raise还可以对相似类型的使用括号进括起来except (IOError,ValueError)
当在代码中不管是否异常都需要执行时，则使用try...finally，具体代码如下所示
def test1():
try:
print('to do stuff')
raise Exception('hehe')
except Exception:
print('process except')
print('to return in except')
return 'except'
finally:
print('to return in finally')
return 'finally'
test1Return = test1()
print('test1Return: '+test1Return)面向对象的意思把你眼中见到的某一类进行抽象，这一类是有共同属性的，例如人，抽象后发现，人有年龄、身高、体重以及肤色等多个属性，这些属性可以组成一个公共类，抽象出这一个类后，只需要调用这个类中的属性即可实例化一个对象，下面将开始逐渐讲解这个重要的编程概念
在Python中使用class来定义一类事物，这是一个抽象的描述，不是真是存在的，当它实例化后会成为一个真正的事物，也就是所谓的对象，示例代码如下所示
class Person:
pass
p = Person()
print(p)方法代表现实中的行为，比如对人来说身高、体重以及肤色等，示例代码如下所示
class Person1:
def sayHi(self):
print('Hello, how are you?')
p1 = Person1()
p1.sayHi()当使用类来构造一个对象的时候，通常在构造之初需要把对象本身的关键属性进行初始化，通常使用构造函数来进行，示例代码如下所示
class Person2:
def __init__(self, name):
self.name = name
def sayHi(self):
print('Hello, I am', self.name)
p2 = Person2('Tim')
p2.sayHi()其中__init__为构造函数名，可以自定义传入参数的类型和个数
变量代表属性和数据，python中变量有两种，即类变量和对象变量，前者是全局的，对每个对象都是共享的，后者是实例化的，每个对象之间互不影响，示例代码如下
class Person3:
population = 0
def __init__(self,name):
self.name = name
print('(Initializing %s)' % self.name)
Person3.population += 1
def sayHi(self):
print('Hi, my name is %s.' % self.name)
def howMany(self):
if Person3.population == 1:
print('I am the only person here.')
else:
print('We have %d persons here.' % Person3.population)
Tim = Person3('Tim')
Tim.sayHi()
Tim.howMany()
Lisa = Person3('Lisa')
Lisa.sayHi()
Lisa.howMany()其中population为Person3的类变量，name由于是self.name进行赋值的，这是属于对象的变量。
所谓的继承类似现实中父与子的概念，但是是存在区别的，代码中的继承是指一些子类从父类中继承某些特性（可以理解为复用），比如人都有眼睛、鼻子以及嘴巴，但是人分亚洲人、欧洲人以及非洲人等，那么可以理解人为父类，亚洲人等为子类，这些子类继承父类中所共有的眼睛、鼻子以及嘴巴等，之后每个子类再有自己的特殊属性，如肤色等，下面是示列代码
class SchoolMember: #父类
# 构造函数__init__初始化属性
def __init__(self,name,age): # 属性
self.name = name
self.age = age
print('(Initialized SchoolMember: {})'.format(self.name))
def tell(self): # 方法
print('Name:"{}" Age:"{}"'.format(self.name,self.age),end=" ")
class Teacher(SchoolMember): #子类继承父类
def __init__(self,name,age,salary):
SchoolMember.__init__(self,name,age) # 调用父类的构造函数
self.salary = salary
print('(Initialized Teacher: {})'.format(self.name))
def tell(self):
SchoolMember.tell(self) # 调用父类的方法
print('Salary: "{:d}"'.format(self.salary))
class Student(SchoolMember): #子类继承父类
def __init__(self,name,age,marks):
SchoolMember.__init__(self,name,age) # 调用父类的构造函数
self.marks = marks
print('(Initialized Student: {})'.format(self.name))
def tell(self):
SchoolMember.tell(self) # 调用父类的方法
print('Marks: "{:d}"'.format(self.marks))
t = Teacher('Mrs. Shrividya',40,30000)
s = Student('Swaroop',25,75)
print() # 空行
members = [t,s]
for member in members:
member.tell() # 这里会自动调用相应类的方法实现动物的分类，并调用对应动物子类的方法
class Animal:
def __init__(self,name,species,color):
self.name = name
self.species = species
self.color = color
def info(self):
print(f"Name: {self.name}, Species: {self.species}, Color: {self.color}")
class Tiger(Animal):
def __init__(self,name,species,color,speed):
Animal.__init__(self,name,species,color)
self.speed = speed
def run(self):
print(f"{self.name} the {self.species} runs at {self.speed} km/h")
class Chiken(Animal):
def __init__(self,name,species,color,food):
Animal.__init__(self,name,species,color)
self.food = food
def eat(self):
print(f"{self.name} the {self.species} eats {self.food}")
tiger1 = Tiger("Tony","Tiger","Orange",80)
tiger1.info()
tiger1.run()
chiken1 = Chiken("Chicky","Chiken","Yellow","rice")
chiken1.info()
chiken1.eat()