python 2x,python基础2

函数应用语法

def 函数名(参数列表)：

"函数_文档"

执行的语句

如果没有执行语句可以使用pass

参数

赋值：

按顺序

关键字：允许赋值的顺序和定义的顺序不一致

默认值：定义函数可以给参数默认值

不定长参数 *

在参数前放置*

通常放在参数的最后

全局变量和局部变量

定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域

练习

计算指定整数的阶乘： 5！=5*4*3*2*1

要求：

用户输入整数

使用函数

2。 猜数游戏

游戏规则： 随机产生四位数字   ABCD

然后让用户输入：四位的数字

根据位置进行判断： 如果位置对，数也对   1A,如果数字对1B

例如：随机产生的数字是： 1234

用户输入的数字是  1924       2A1B

用户输入的数字是  5678       0A0B

用户输入的数字是  4123       0A4B

用户输入的数字是 1234        恭喜答对了

要求用户只能猜10次，同时要求产生的随机数每个位置的数字不能相同，例如  1123 不合法的随机数

考虑使用函数开发

# def factorial(num):

# result=1

# if num<=2:

# return num

# for i in range(2,num+1):

# result*=i

# return result

def factorial(num):

if num==1:

return 1

else:

return num*factorial(num-1)#递归适用于数不多的

def main():

temp=int(input("输入："))

rs=factorial(temp)

print("%d的阶乘结果是%d"%(temp,rs))

main()

import random

def randomList():

arr1=[1,2,3,4,5,6,7,8,9]

return random.sample(arr1,4)#随机不重复取4个

def compare(num,arr):

rs={}

rs["A"]=0

rs["B"]=0

for i in range(len(arr)):

temp=int(num[i])

if(temp==arr[i]):

rs["A"]+=1

elif temp in arr:

rs["B"]+=1

return rs

def main():

arr=randomList()#生成随机数

# num=input("请输入4位整数: ")

# rs=compare(num,arr)

i=0

rs={"A":0}

while i<10 and rs["A"]<4:

i+=1

num = input("请输入4位整数: ")

rs = compare(num, arr)

if (rs["A"] == 4):

print("恭喜！")

else:

print("%s:%dA%dB" % (num, rs["A"], rs["B"]))

if i>10 and rs["A"]<4:

print("很遗憾",arr)

main()

类和对象面向对象技术简介

类 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。

对象 对象是类的实例。通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法。

类变量 变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

数据成员 类变量或者实例变量, 用于处理类及其实例对象的相关的数据。

方法重写 如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖(override)，也称为方法的重写。

局部变量 定义在方法中的变量，只作用于当前实例的类。

实例变量 在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。

继承 即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个(is-a)"关系(例，Dog是一个Animal)。

实例化 创建一个类的实例，类的具体对象。

方法 类中定义的函数。

创建类

使用 class 语句来创建一个新类，class 之后为类的名称并以冒号结尾:

class 类名 ：

'类的帮助信息' #类文档字符串

class_suite #类体

实例化

变量=类名()

变量=类名(参数)

class Bases:

#构造方法

def __init__(self,name):

self.name=name

self.hp=100

self.power=10

def show(self):

print("hello")

t1=Bases("张三")

print(t1)

print(t1.name)

print(t1.hp)

print(t1.power)

t1.show()

三。 方法和属性

访问属性

通过 . 访问

通过函数访问

getatter(对象名，属性名) 访问对象属性

setatter(对象名，属性名，值)设置一个属性的值，如果属性不存在，则会创建一个新的属性

hasatter(对象名,属性名)检查一个属性是否存在

delatter(对象名，属性名)删除属性

类属性

类属性不属于任意一个对象

自定义类变量

class Student:

number=0

def __init__(self,name):

self.name=name

Student.number+=1

stu1=Student("aa")

stu2=Student("cc")

stu3=Student("cc")

print(Student.number)

内置类变量

_ _dict_ _ 类属性 (包含一个字典，由类的数据属性组成)

_ _doc_ _ 类的文档字符串

_ _name_ _ 类名

_ _module_ _ 类定义所在的模块

_ _bases_ _:类的所有父类构成的元素

方法

使用 def进行定义，第一个参数必须是self，在使用方法无需给self赋值

类方法

使用def进行定义，参数为cls, 使用@classmethod进行注解，使用类名进行调用

class Student:

number=0

def __init__(self,name):

self.name=name

Student.number+=1

@classmethod

def showNumber(self):

print(Student.number)

Student.showNumber()

私有方法和私有属性

以双_ _开头，私有属性或方法不能在类的外部被使用或直接访问

@property的用法与神奇之处 (装饰器),一旦给函数加上一个装饰器@property,调用函数的时候不用加括号就可以直接调用函数了

class Student:

def __init__(self,name,score):

self.name=name

self.__score=score

def show(self):

print(self.name,self.__score)

self.__hello()

@property

def score(self):

print(self.__score)

def setScore(self,score):

self.__score=score

def __hello(self):

print("hello")

stu1=Student("小明",59)

print(stu1.name)

# print(stu1.__score)

stu1.show()

#stu1.score()

stu1.score

四。 继承

语法

class 类名(父类名)：

注意事项

在创建子类的过程中，你需要手动调用父类的构造函数__init__来完成子类的构造。

在子类中调用父类的方法时，需要加上父类的类名前缀，且需要带上self参数变量。比如SchoolMember.tell(self), 这个可以通过使用super关键词简化代码。

如果子类调用了某个方法(如tell())或属性，Python会先在子类中找，如果找到了会直接调用。如果找不到才会去父类找。这为方法重写带来了便利。

五。重写

写法的重写

如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法：

class Bases:

def __init__(self,name):

self.name=name

def show(self):

print("bases show",self.name)

class Student(Bases):

def __init__(self,name,score):

Bases.__init__(self,name)

self.score=score

def say(self):

super().show()

def show(self):

print("student shwo ",self.name,self.score)

基础方法重写

运算符重写

# def show():

# pass#占位

# show()

# def show(name,age,score=0):

# print("%s,%d,%f"%(name,age,score))

# show("xiaoming",20,66.6)

#

# show(age=28,name="zhangsan",score=89)

# show(age=18,name="lisi")

#

# def conn(url,databasename,post=3306,user='root',pwd='root'):

# pass

#不定长参数

# def show(name,*score):

# print("xingming",name)

# for sc in score:

# print("chengji",sc)#+两边必须都是字符串

# # show(60,70,80,90,name="xiaoming")

# show("lisi",90,60)

# arr=int(input("输入一个整数"))

# def jisuan(arr):

# if arr==0 or arr==1:

# return 1

# else:

# return (jisuan(arr-2)+jisuan(arr-1))

#

# print (jisuan(arr))

# n=int(input("输入一个整数"))

# def fib(n):

# if n == 1:

# return [1]

# if n == 2:

# return [1, 1]

# fibs = [1, 1]

# for i in range(2, n):

# fibs.append(fibs[-1] + fibs[-2])

# return fibs

# print(fib(n))

#创建类

# class Bases:

# def __init__(self,name):

# self.name=name

# self.power=100

# def show(self):

# print("hello")

# #构造方法

#

# t1=Bases("zhangsan")

# print(t1)

# print(t1.name)

# print(t1.power)

# t1.show()

#

# delattr(t1,"name")

# rs=hasattr(t1,"name")#boolean

# print(rs)

# setattr(t1,"name","lisi")#不存在添加

# t1.a=10

# print(t1)#也可以加属性

# print(getattr(t1,"name"))

#类属性

class Student:

number=0

def __init__(self,name):

self.name=name

Student.number+=1

@classmethod #类方法

def showNumber(self):

print(Student.number)

def __del__(self):

Student.number-=1

#

# stu1=Student("a")

# stu2=Student("c")

# print(Student.number)

# Student.showNumber()

# #内置类变量

# print(Student.__bases__)

# print(Student.__module__)

class Student:

def __init__(self,name,score): #构造方法

self.name=name

self.__score=score

def show(self):

print(self.name,self.__score)

self.__hello()

@property #装饰器 属性

def score(self):

print(self.__score)

def __hello(self):

print("hello")

def setScore(self,score):

self.__score=score

stu1=Student("a",59)

print(stu1.name)

print(stu1.__score)#报错，私有属性

stu1.show()

stu1.score

# class Bases:

# def __init__(self,name):

# self.name=name

# def show(self):

# print("bases show",self.name)

#

# class Student(Bases):

# def __init__(self,name,score):

# Bases.__init__(self,name)#必须有self

# self.score=score

#

# def say(self):

# super().show()#super()父类对象

#

# def show(self):

# print("student",self.name,self.score)

# b=Bases("a")

# b.show()

# s=Student("a",100)

# s.show()

# s.say()

#运算符重写

# class Student:

# def __init__(self,name,score):

# self.name=name

# self.score=score

# def __str__(self):

# return "%s的成绩是%f"%(self.name,self.score)

# def __add__(self, other):

# return Student("%s+%s"%(self.name+other.name),self.score+other.score)

# s1=Student("a",90)

# s2=Student("b",90)

# print(s1+s2)

# print(s1)

六. 多继承

语法：

class 类名(父类名1，父类名2，。。。。)：

你可以使用issubclass()或者isinstance()方法来检测。issubclass() - 布尔函数判断一个类是另一个类的子类或者子孙类，

语法：issubclass(sub,sup) isinstance(obj, Class) 布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true。

标签：__,name,python,self,基础,score,print,def

来源： https://www.cnblogs.com/yangyujia/p/14546215.html