一、Def函数的使用
I）、Def实例II)、利用Def函数进行循环结构III）、函数调用
<1*>.调用函数说明<2*>. 函数实例 VI)、Python传可变对象实列
<1*>.函数说明 V)、调用printinfo 函数IV)、sum函数
《1》、函数实例 二、Python集合
I)、集合的定义II)、实列III)、计算与清空 三、Python案例实训集合
1*. 生成随机数列2*. Python摄氏温度转华氏温度3*. Python交换变量4*. Python判断字符串是否为数字5*. Python判断素数 合数6*. Python九九乘法表7*. Python 斐波那契数列8*. Python 阿姆斯特朗数 四、Python面向对象
I）、实例II）、类的方法III）、单继承与多继承VI）、方法重写V)、运算符转载 五、蓝桥杯算法解答链接六、网络爬虫Requestes
I）、需求:爬取搜狗首页的页面数据II)、使用UA伪装 求取关键词页面
一、Def函数的使用 I）、Def实例def hello():
print("Hello word")
hello()
II)、利用Def函数进行循环结构
def max(a,b):
if a>b:
return a
else:
return b
a=5
b=4
print(max(a,b))
利用def函数计算面积函数
def area(width,heigh):
return width*heigh
def print_weclome(name):
print("Welcome",name)
print_weclome("Runoob")#对name进行赋值
w=4
h=5
print("width=",w,"height=",h,"area=",area(w,h))
III）、函数调用
<1*>.调用函数说明
定义一个函数：给了函数一个名称，指定了函数里包含的参数，和代码块结构。
这个函数的基本结构完成以后，你可以通过另一个函数调用执行。也可以直接从 Python 命令提示符执行。如下实例调用了 printme() 函数
定义函数
<2*>. 函数实例
def printme(str):
#打印任何传入的字符串
print(str)
return
#调用函数
printme("我要调用用户自定义函数")
printme("再次调用同一函数")
python传不可变对象实列
def change(a):
print(id(a))#指向的是同一个对象
a=10
print(id(a))#一个新对象
a=1
print(id(a))
print(change(a))
VI)、Python传可变对象实列
<1*>.函数说明
可写函数说明
def changeme(mylist):
mylist.append([1,2,3,4])
print("函数内取值",mylist)
return
#调用changeme函数
mylist=[10,20,30]
#调用函数的意思是把changme下面的代码架构赋值过来并且影响调用函数的这个代码结构
print("函数外取值:",mylist)
changeme(mylist)
必需参数须以正确的顺序传入函数，调用的数量必须和声明时的一样。
调用printme（）函数，你必须传入一个参数，不然会出现语法错误：
def printme(str):#def 函数名称(参数)
"打印任何输入的字符串"
print(str)
return
#打印printme函数，不加参数会报错
printme(str="菜鸟教程")#调用函数必须要函数名称(参数)也可以对参数进行赋值
可写函数说明
def printinfo(name,age=3):
"打印任何输入的字符串"
print("名字:",name)
print("年龄:",age)
return
printinfo(name="雷云腾",age="19")#对参数进行赋值
printinfo(name="雷帅")#调用函数时，如果没有传递参数，则会使用默认参数，以下实列中如果没有传入age参数，则使用括号默认值
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会命名 》不定长参数
加了*号的参数会以元组tuple的形式导入，存放所有未命名的变量参数。
def printinfo(arg1,*vartuple):
"打印任何输入的参数"
print("输出:")#输入输出条件代码
print(arg1)
print(vartuple)
#调用printinfo函数
printinfo(70,65,50,32)#输入代码条件
如果在函数调用时没有指定参数，它就是一个空元组。我们也可以不向函数传递未命名的变量
可写函数说明
def printinfo(arg1, *vartuple):
"打印任何传入的参数"
print("输出: ")
print(arg1)
for var in vartuple:#可取消元组符号
print(var)
return
V)、调用printinfo 函数
printinfo(1, a=2, b=3)#代码条件
匿名函数
python 使用 lambda 来创建匿名函数。
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
可写函数说明
sum = lambda arg1, arg2: arg1 + arg2#lambda 函数的语法只包含一个语句#使用lambda定义参数后：再定义条件
print("相加后的值为 : ", sum(10, 20))
print("相加后的值为 : ", sum(20, 20))
diff=lambda dif1,dif2:dif1-dif2
#调用diff函数
print("相减后的值为:",diff(30,20))
print("相减后的值为:",diff(10,20))
return语句
return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。
不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，
可写函数说明
def sum(arg1, arg2):
# 返回2个参数的和."
total = arg1 + arg2
print("函数内 : ", total)
return total
IV)、sum函数
《1》、函数实例
total = sum(10, 20)#必须要出现以total为名赋值的表达式
print("函数外 : ", total)
Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。
在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 和 f 要求为关键字形参:
print(f(10, 20, 30, d=40, e=50, f=60))
二、Python集合
I)、集合的定义
集合(set)是一个无序的不重复元素序列。创建一个空集合必须使用set()而不是{}。因为{}是用来创建一个字典的。
```python
basket={'apple','orange','apple','pear','orange','banana'}#集合会去掉重复值
print(basket)
a=set('abracadabra')#去掉重复值
b=set('alacazam')
print(a-b)#集合a中包含而集合b中不包含的元素（相同元素不输出 a中跟b不相同的 a全部输出）
print(a|b)#集合a和b中包含的所有元素 并集
print(a&b)#交集
print(a^b)#差集(减去相同的元素）剩下的都输出
II)、实列
c={x for x in a if x not in 'rd'}#差集
print(c)
#添加元素(add和update)
thisset=set(("Goole","Runoob","Taobao"))
thisset.add("Facebook")#add增加文本型
thisset.add("Macbook")
thisset.update({1,2,3,4,5})#{}内地参数可以是列表、元组，字典，。
#移除元素
thisset.remove("Taobao")#移除元素淘宝 不存在会发生错误.
#移除元素第二种。
thisset.discard("Taobao")#不存在不会发生错误。
#s.pop()删除集合中开头或结尾的一个元素
#strip函数的用处是替换符号，达到删除空元素的作用， 也是可以理解为删除一个位置元素
III)、计算与清空
#计算集合元素个数
print(len(thisset))
#清空集合
#thisset.clear()清空集合内的所有元素
#判断元素是否在集合中存在
print('orange' in basket)#返回布尔型数据
三、Python案例实训集合
1*. 生成随机数列
import random target=random.randint(1,10) print(target)2*. Python摄氏温度转华氏温度
接收用户输入
Celsius=float(input("输入摄氏度:"))
#计算华氏摄氏度
fahrenheit=(Celsius*1.8)+32
print("%0.1f摄氏度转换为华氏温度为%0.1f" %(Celsius,fahrenheit))
3*. Python交换变量
x=input("输入x值:")
y=input("输入y值:")
#创建临时变量,并交换
temp=x
x=y
y=temp
print('交换后x的值为:{}'.format(x))
print('交换后y的值为:{}'.format(y))
交换变量
x=input("输入x值:")
y=input("输入y值:")
x,y=y,x
print("交换后x的值为:{}".format(x))
print("交换后y的值为:{}".format(y))
4*. Python判断字符串是否为数字
自定义函数is_number()
判断一个字符串是否为数字
def is_number(s):
try:
float(s)
return True
except ValueError:
pass
try:
import unicodedata
unicodedata.numeric(s)
except (TypeError,ValueError):
pass
return False
print(is_number('1230'))
print(is_number("lyt"))
5*. Python判断素数 合数
number=int(input("请输入一个整数:"))
flag=True
for i in range(2,int(number)):
if number % i==0:
flag=False
break
if number==1:
print("既不是素数也不是合数")
elif flag:
print("{}是素数".format(number))
else:
print("{}是合数".format(number))
6*. Python九九乘法表
for i in range(1,10):
for j in range(1,i+1):
print("{}×{}={}t".format(i,j,i*j),end="")
print()
7*. Python 斐波那契数列
count=0
a,b=0,1
while b<100000000:
count+=1
print(b,end=" ")
a,b=b,a+b
if count%5==0:
print()
8*. Python 阿姆斯特朗数
如果一个n位正整数等于其各位数字的n次方之和,则称该数为阿姆斯特朗数
获取用户输入的数字
num=int(input("请输入一个数字"))
#初始化变量sum
sum=0
n=len(str(num))#指数
temp=num#检测
while temp>0:
digit=temp%10
sum+=digit**n
temp//=10
#输出结果
if num==sum:
print(num,"是阿姆斯特朗数")
else:
print(num,"不是阿姆斯特朗数")
四、Python面向对象
类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。方法：类中定义的函数。类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。局部变量：定义在方法中的变量，只作用于当前实例的类。实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量，实例变量就是一个用 self 修饰的变量。继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。实例化：创建一个类的实例，类的具体对象。对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
类定义
I）、实例
class MyClass:
"""一个简单的类实例"""
i=12345
def f(self):#方法：类中定义的函数。
return "hello world"
#实例化类
x=MyClass() #创建一个类的实例.对象包括两个数据成员(类变量和实例变量)和方法
print("Myclass类的属性i为",x.i)
print("Myclass类的方法f输出为",x.f())
类有一个名为 init() 的特殊方法（构造方法），该方法在类实例化时会自动调用，init_() 方法可以有参数，参数通过 init() 传递到类的实例化操作
class Complex:
def __init__(self,realpart,imagpart):
self.r=realpart
self.i=imagpart
x=Complex(3**2,-4.5+4+0.5)#实例化操作并且自动调用,可以对括号内的参数进行加减乘除
print(x.r,x.i)#输出结果:3.0 -4.5
class Test:
def prt(self):#slef代表的是类的实例,代表当前对象的地址,而self.class则指向类
print(self)
print(self.__class__)
t=Test()#类的实例化
t.prt()
II）、类的方法
在类的内部使用def关键字来定义一个方法,
类定义 分三部分 第一部分为定义属性 名称 def间隔 第二部分采用定义方法 第三部分赋值实例化并且打印输出
class people:
#定义基本属性
name=''
age=0
#定义私有属性,私有属性在类外部无法直接进行访问
__weight=0
#定义构造方法
def __init__(self,n,a,w):
self.name=n
self.age=a
self.__weight=w
def speak(self):
print("%s 说:我%d岁." %(self.name,self.age))
#实例化类
p=people('runoob',10,30)#赋值实例化
p.speak()#打印输出实例化
III）、单继承与多继承
继承 子类（派生类 DerivedClassName）会继承父类（基类 baseClassName）的属性和方法
class people:
name=''
age=0
__weight=0
def __init__(self,n,a,w):
self.name=n
self.age=a
self.__weight=w
def speak(self):
print("%s说:我%d岁." %(self.name,self.age))
#单继承示例
class student(people):
grade=''
def __init__(self,n,a,w,g):
#调用父类的构函
people.__init__(self,n,a,w)
self.grade=g
#覆写父类的方法
def speak(self):
print("%s说:我%d岁了,我在读%d年级" %(self.name,self.age,self.grade))
#第一个class是父类 第二个class是子类
s=student("LYT",19,76,13)
s.speak()
多重继承
class people:#定义父类
#定义基本属性
name=''
age=0
__weight=0
#定义构造方法
def __init__(self,n,a,w):#定义参数
self.name=n
self.age=a
self.__weight=w#定义基本属性
#打印
def sepak(self):
print("%s 说:我%d岁." %(self.name,self.age))
#单继承示例
class student(people):#子类
grage=''
def __init__(self,n,a,w,g):
#调用父类的构成函数
people.__init__(self,n,a,w)#people.__init__(self,n,a,w)#单继承需要写的
self.grade=g
#覆写父类的方法
def speak(self):
print("%s说:我%d岁了,我在读%d年级" %(self.name,self.age,self.grade))
#另一个类,多重继承之前的准备
class speaker():
topic=''
name=''
def __init__(self,n,t):#%(self.name,self.topic 字母顺序与打印输出对应
self.topic=t#顺序不用对应
self.name=n
def speak(self):
print("%s说,我是一名演说家,我的主题是%s" %(self.name,self.topic))
#多重继承
class sample(speaker,student):
a=''
def __init__(self,n,a,w,g,t):
student.__init__(self,n,a,w,g)#多继承需要写的
speaker.__init__(self,n,t)
test=sample("LYT",25,80,4,"python")
test.speak()#方法名同,默认调用的是在括号中参数位置排前父类的方法
VI）、方法重写
如果你的父类方法的功能不能满足你的需求,你可以在子类重写你父类的方法。
class Parent: #定义父类
def myMethod(self):
print("调用父类的方法")
class Child(Parent):#定义子类
def myMethod(self):
print("调用子类方法")
c=Child()#子类实例
c.myMethod()#子类调用重写方法
super(Child,c).myMethod()#用子类对象调用父类已被覆盖的方法
#super函数是用于调用父类的一个方法
类的私有属性
__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
类的方法 #可以使用this
在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。
class JustCounter:
__secretCount=0 #私有变量
publicCount=0 #公开变量
def count(this):
self.__secretCount +=1
self.publicCount +=1
print(self.__secretCount)
V)、运算符转载
class Vector:
def __init__(self,a,b):
self.a=a
self.b=b
def __str__(self):
return 'Vector (%d,%d)' %(self.a,self.b)
def __add__(self, other):
return Vector(self.a+other.a,self.b+other.b)
v1=Vector(2,10)
v2=Vector(5,-2)
print(v1+v2)
乘法运算
class Vector:
def __init__(self,a,b):
self.a=a
self.b=b
def __str__(self):
return 'Vector (%d,%d)' %(self.a,self.b)
def __mul__(self, other):
return Vector(self.a*other.a,self.b*other.b)
v1=Vector(2,5)
v2=Vector(3,5)
print(v1*v2)
五、蓝桥杯算法解答链接
https://blog.csdn.net/m0_62491934/article/details/122890702
平方怪圈
https://blog.csdn.net/m0_62491934/article/details/122890720
煤球数目
https://blog.csdn.net/m0_62491934/article/details/122890746
平方末尾
https://blog.csdn.net/m0_62491934/article/details/122890773
集合内取交集
https://blog.csdn.net/m0_62491934/article/details/122890803
有奖猜谜
https://blog.csdn.net/m0_62491934/article/details/122903998
破译密码
https://blog.csdn.net/m0_62491934/article/details/122933588
十五道入门+简单+中等算法题
还有很多就等读者们自己去看了,后续也会发出来。 六、网络爬虫Requestes I）、需求:爬取搜狗首页的页面数据
import requests
if __name__=='__main__':
#step 1:搜索Url
url='https://123.sogou.com/'
#step 2:发起请求
#get方法会返回一个响应对象
response=requests.get(url=url)
#step 3:获取响应数据,text返回的是字符串形式的响应数据
page_text=response.text
print(page_text)
#step 4:持久化存储
with open('./sogou.html','w',encoding='utf-8') as fp:
fp.write(page_text)
print("爬取数据结束")
II)、使用UA伪装 求取关键词页面
import requests
if __name__=='__main__':
#UA伪装:将对应的User-Agent封装到一个字典中
headers={
'User-Agent':'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/98.0.4758.9 Safari/537.36'
}
url='https://www.sogou.com/sie?'
#处理url携带的参数:封装到字典中
kw=input('enter a word:')
param={
'query':kw
}
#对指定的url发起的请求对应的url是携带参数的,并且请求过程中处理了参数
response=requests.get(url=url,params=param,headers=headers)#headers是伪装 params输入关键词
page_text=response.text#以文本的形式输出
fileName=kw+'.html'#存储为网页形式
with open(fileName,'w+',encoding='utf-8') as fp:
fp.write(page_text)#写入fp
print(fileName,"保存成功！！")
## 欢迎各位评论留言
