面向对象基础
面向对象编程介绍
'''
面向过程的编程思想
核心过程二字,过程指的是解决问题的步骤,即先干什么\再干什么\后干什么
基于该思想编写程序就好比在设计一条流水线,是一种机械式的思维方式
优点:复杂的问题流程化\进而简单化
缺点:可扩展性差
面向对象的编程思想
核心是对象二字,对象是特征与技能的结合体
基于该思想编写程序(脑子始终想的是对象二字)就好比在创造一个世界,世界是由一个个对象组成,在上帝眼里任何存在的事物都是对象,任何不存在的事物也都可以造出来,是一种上帝式的思维方式
优点: 可扩展性强
缺点: 编程的复杂度要高与面向过程
类:
对象是特征与技能的结合体,而类则是一系列对象相同的特征与技能的结合体
强调:
1.对象是具体存在的事物,而类则一个抽象的概念
2.站在不同的角度总结出的类与对象是不同的
在现实世界中:先有一个个具体存在的对象,然后随着人类文明的发展才总结出类的概念
在程序中: 先定义类,后调用类来产生对象
站在老男孩选课系统的角度
总结出现实世界中的老男孩学生对象:
学生对象1
特征
school='oldboy'
name='李铁蛋'
age=18
sex='male'
技能
选课
学生对象2
特征
school='oldboy'
name='赵钢弹'
age=38
sex='female'
技能
选课
学生对象3
特征
school='oldboy'
name='刘银弹'
age=28
sex='male'
技能
选课
老师对象1
特征
school='oldboy'
name='Egon'
age=18
sex='male'
level=10
技能
打分
总结现实世界中的老男孩学生类
相同的特征
school='oldboy'
相同的技能
选课
在程序中....
'''
类的使用
'''
站在老男孩选课系统的角度
总结出现实世界中的老男孩学生对象:
学生对象1
特征
school='oldboy'
name='李铁蛋'
age=18
sex='male'
技能
选课
学生对象2
特征
school='oldboy'
name='赵钢弹'
age=38
sex='female'
技能
选课
学生对象3
特征
school='oldboy'
name='刘银弹'
age=28
sex='male'
技能
选课
总结现实世界中的老男孩学生类
相同的特征
school='oldboy'
相同的技能
选课
'''
class OldboyStudent:
school = 'oldboy'
def choose_course(self):
print('choosing course')
print(OldboyStudent.__dict__)
print(OldboyStudent.school)
print(OldboyStudent.choose_course)
OldboyStudent.school='OLDBOY'
OldboyStudent.country='China'
del OldboyStudent.country
print(OldboyStudent.__dict__)
OldboyStudent.choose_course(123123)
对象的使用
'''
学生对象1
特征
school='oldboy'
name='李铁蛋'
age=18
sex='male'
技能
选课
学生对象2
特征
school='oldboy'
name='赵钢弹'
age=38
sex='female'
技能
选课
学生对象3
特征
school='oldboy'
name='刘银弹'
age=28
sex='male'
技能
选课
'''
class OldboyStudent:
school = 'oldboy'
def choose_course(self):
print('choosing course')
stu1=OldboyStudent()
stu2=OldboyStudent()
stu3=OldboyStudent()
'''
# name='李铁蛋'
# age=18
# sex='male'
stu1.name='李铁蛋'
stu1.age=18
stu1.sex='male'
print(stu1.__dict__)
# name='赵钢弹'
# age=38
# sex='female'
stu2.name='赵钢弹'
stu2.age=38
stu2.sex='female'
print(stu2.__dict__)
# name='刘银弹'
# age=28
# sex='male'
stu3.name='刘银弹'
stu3.age=28
stu3.sex='male'
print(stu3.__dict__)
'''
'''
def init(obj,name,age,sex):
obj.name = name
obj.age = age
obj.sex = sex
# stu1.name='李铁蛋'
# stu1.age=18
# stu1.sex='male'
init(stu1,'李铁蛋',18,'male')
# stu2.name='赵钢弹'
# stu2.age=38
# stu2.sex='female'
init(stu2,'赵钢弹',38,'female')
# stu3.name='刘银弹'
# stu3.age=28
# stu3.sex='male'
init(stu3,'刘银弹',28,'male')
print(stu1.__dict__)
print(stu2.__dict__)
print(stu3.__dict__)
'''
class OldboyStudent:
school = 'oldboy'
def __init__(obj, name, age, sex):
obj.name = name
obj.age = age
obj.sex = sex
def choose_course(self):
print('choosing course')
stu1=OldboyStudent('李铁蛋',18,'male')
stu2=OldboyStudent('赵钢弹',38,'female')
stu3=OldboyStudent('刘银弹',28,'male')
属性查找
xxx=33333
class OldboyStudent:
school = 'oldboy'
yyy=333
count=0
def __init__(obj, name, age, sex):
OldboyStudent.count+=1
obj.name = name
obj.age = age
obj.sex = sex
def choose_course(self):
print('choosing course')
stu1=OldboyStudent('李铁蛋',18,'male')
print(stu1.__dict__)
print(OldboyStudent.__dict__)
stu1.xxx=111
print(stu1.__dict__)
print(stu1.xxx)
stu1=OldboyStudent('李铁蛋',18,'male')
stu2=OldboyStudent('赵钢弹',38,'female')
stu3=OldboyStudent('刘银弹',28,'male')
stu1.school=123
绑定方法
class OldboyStudent:
school = 'oldboy'
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
def choose_course(self,x):
print('%s choosing course' %self.name)
stu1=OldboyStudent('李铁蛋',18,'male')
stu2=OldboyStudent('赵钢弹',38,'female')
stu3=OldboyStudent('刘银弹',28,'male')
一切皆对象
class Foo:
pass
l1=[1,2,3]
l1.append(4)
print(l1)
l2=['a','b','c']
l2.append('d')
三大特性之一:继承
继承介绍
'''
1 什么是继承
继承一种新建类的方式,新建的类称之为子类/派生类,被继承的类称之为父类\基类\超类
python中继承的特点:
1. 子类可以遗传/重用父类的属性
2. python中一个子类可以同时继承多个父类
3. 在继承背景下去说,python中的类分为两种:新式类,经典类
新式类: 但凡继承了object的类Foo,以及该类的子类...都是新式类
在python3中一个类即便是没有显式地继承任何类,默认就会继承object
即python3中所有的类都是新式类
经典类:没有继承object的类,以及该类的子类...都是经典类
在python2中才区分新式类与经典类,
在python2中一个类如果没有显式地继承任何类,也不会继承object
2 为何要用继承
减少类与类之间代码冗余
3 如何用继承
'''
class Parent1(object):
pass
class Parent2(object):
pass
class Sub1(Parent1):
pass
class Sub2(Parent1,Parent2):
pass
print(Parent1.__bases__)
print(Parent2.__bases__)
print(Sub1.__bases__)
print(Sub2.__bases__)
class Parent1(object):
xxx=333
class Sub1(Parent1):
pass
obj=Sub1()
print(obj.xxx)
利用继承来解决类与类之间代码冗余问题
class OldboyPeople:
school = 'Oldboy'
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
class OldboyStudent(OldboyPeople):
def choose_course(self):
print('%s choosing course' % self.name)
class OldboyTeacher(OldboyPeople):
def score(self,stu,num):
stu.score=num
stu1=OldboyStudent('刘二蛋',38,'male')
print(stu1.__dict__)
tea1=OldboyTeacher('egon',18,'male')
print(tea1.__dict__)
在子类派生的新方法中重用父类功能的方式一
class OldboyPeople:
school = 'Oldboy'
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
class OldboyStudent(OldboyPeople):
def __init__(self, name, age, sex, score=0):
OldboyPeople.__init__(self,name,age,sex)
self.score = score
def choose_course(self):
print('%s choosing course' % self.name)
class OldboyTeacher(OldboyPeople):
def __init__(self,name,age,sex,level):
OldboyPeople.__init__(self,name,age,sex)
self.level=level
def score(self,stu,num):
stu.score=num
stu1=OldboyStudent('刘二蛋',38,'male')
print(stu1.__dict__)
tea1=OldboyTeacher('egon',18,'male',10)
print(tea1.__dict__)
在单继承背景下的属性查找
class Foo:
pass
class Bar1(Foo):
pass
class Bar2(Bar1):
pass
obj=Bar2()
print(obj.xxx)
class Foo:
def f1(self):
print('Foo.f1')
def f2(self):
print('Foo.f2')
self.f1()
class Bar(Foo):
def f1(self):
print('Bar.f1')
obj=Bar()
obj.f2()
'''
Foo.f2
Bar.f1
'''
在多继承背景下的属性查找
class G:
pass
class E(G):
pass
class F:
pass
class B(E):
pass
class C(F):
pass
class D:
pass
class A(B, C, D):
pass
obj = A()
print(obj.x)
class G(object):
pass
class E(G):
pass
class F(G):
pass
class B(E):
pass
class C(F):
pass
class D(G):
pass
class A(B, C, D):
pass
obj=A()
print(obj.x)
print(A.mro())
在子类派生的新方法中重用父类功能的方式二
class OldboyPeople:
school = 'Oldboy'
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
class OldboyStudent(OldboyPeople):
def __init__(self, name, age, sex, score=0):
super(OldboyStudent,self).__init__(name,age,sex)
self.score = score
def choose_course(self):
print('%s choosing course' % self.name)
class OldboyTeacher(OldboyPeople):
def __init__(self,name,age,sex,level):
super().__init__(name,age,sex)
self.level=level
def score(self,stu,num):
stu.score=num
stu1=OldboyStudent('刘二蛋',38,'male')
print(stu1.__dict__)
tea1=OldboyTeacher('egon',18,'male',10)
print(tea1.__dict__)
class A:
def f1(self):
print('A.f1')
super().f2()
class B:
def f2(self):
print('B.f2')
class C(A,B):
def f2(self):
print('C.f2')
obj=C()
print(C.mro())
obj.f1()
'''
[<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
A.f1
B.f2
'''
继承总结
1. 什么是继承
继承是一种新建类的方式,新建的类称之为子类/派生类,被继承的类称之为父类/基类/超类
继承有3个特点:
1. 子类可以遗传/重用父类的属性(解决类与类之间代码冗余的问题)
2. 在python中一个子类可以同时继承多个父类
3. 在继承的背景下,类分为两种:新式类,经典类
新式类:但凡继承object类的子类,以及该子类的子子孙孙都是新式类
在python3中一个类即便是没有显式地继承任何类,默认就继承object类,
即在python3中所有类都是新式类
经典类:没有继承object类的子类,以及该子类的子子孙孙都是经典类
强调:只有在python2中才有经典类
在python2中如果一个类没有显式地继承任何类,并不会自动继承object类
2. 为何要用继承:减少类与类之间的代码冗余
3. 如何继承
class Foo:
pass
class Bar(Foo):
pass
Bar.x
4. 属性查找
在没有出现菱形继承的情况下,属性的查找是按照从左往右的顺序一个分支一个分支的找下去
在出现菱形继承(一个子类继承的多个分支最终汇聚到一个非object类)的情况下,
新式类:广度优先查找,按照从左往右的顺序一个分支一个分支的找下去,在最后一个分支才去查找顶级类
经典类:深度优先查找,按照从左往右的顺序一个分支一个分支的找下去,在第一个分支就查找顶级类
5. 派生
在子类中定义自己的属性,如果与父类的属性重名,那以自己的为准.
在子类派生的新方法中重用父类的功能:
方式一:指名道姓地调用某一个类的函数
特点:
1. 与继承无关
2. 没有自动传值的效果
方式二:super()得到一个特殊的对象,该对象专门用来引用父类的属性
特点:
1. 严格依赖继承,完全参照mro
2. 有自动传值的效果
组合
'''
1. 什么是组合
组合指的是某一个对象拥有一个属性,该属性的值是另外一个类的对象
class Foo:
pass
class Bar:
pass
obj=Foo()
obj.attr=Bar()
obj.xxx
obj.attr.yyy
2. 为何要用组合
通过为某一个对象添加属性(属性的值是另外一个类的对象)的方式,可以间接地将两个类关联/整合/组合到一起
从而减少类与类之间代码冗余
class Foo1:
pass
class Foo2:
pass
class Foo3:
pass
class Bar:
pass
obj_from_bar=Bar()
obj1=Foo1()
obj2=Foo2()
obj3=Foo3()
obj1.attr1=obj_from_bar
obj2.attr2=obj_from_bar
obj3.attr3=obj_from_bar
3. 如何用组合
class OldboyPeople:
school = 'Oldboy'
def __init__(self,name,age,sex,):
self.name = name
self.age = age
self.sex = sex
class OldboyStudent(OldboyPeople):
def __init__(self, name, age, sex,score=0):
OldboyPeople.__init__(self,name,age,sex)
self.score = score
def choose_course(self):
print('%s choosing course' % self.name)
class OldboyTeacher(OldboyPeople):
def __init__(self,name,age,sex,level):
OldboyPeople.__init__(self,name,age,sex)
self.level=level
def score(self,stu,num):
stu.score=num
class Course:
def __init__(self,c_name,c_price,c_period):
self.c_name = c_name
self.c_price = c_price
self.c_period = c_period
def tell_info(self):
print('<课程名:%s 价钱:%s 周期:%s>' %(self.c_name,self.c_price,self.c_period))
# 创建课程对象
python=Course('python全栈开发',1900,'5mons')
linux=Course('linux架构师',900,'3mons')
stu1=OldboyStudent('刘二蛋',38,'male')
stu1.course=python
# print(stu1.__dict__)
stu1.course.tell_info()
tea1=OldboyTeacher('egon',18,'male',10)
tea1.course=python
# print(tea1.__dict__)
tea1.course.tell_info()
'''
class OldboyPeople:
school = 'Oldboy'
def __init__(self,name,age,sex,):
self.name = name
self.age = age
self.sex = sex
class OldboyStudent(OldboyPeople):
def __init__(self, name, age, sex,score=0):
OldboyPeople.__init__(self,name,age,sex)
self.score = score
self.courses=[]
def choose_course(self):
print('%s choosing course' % self.name)
def tell_all_course(self):
print(('学生[%s]选修的课程如下' %self.name).center(50,'='))
for obj in self.courses:
obj.tell_info()
print('='*60)
class OldboyTeacher(OldboyPeople):
def __init__(self,name,age,sex,level):
OldboyPeople.__init__(self,name,age,sex)
self.level=level
self.courses=[]
def score(self,stu,num):
stu.score=num
def tell_all_course(self):
print(('老师[%s]教授的课程如下' %self.name).center(50,'*'))
for obj in self.courses:
obj.tell_info()
print('*'*70)
class Course:
def __init__(self,c_name,c_price,c_period):
self.c_name = c_name
self.c_price = c_price
self.c_period = c_period
def tell_info(self):
print('<课程名:%s 价钱:%s 周期:%s>' %(self.c_name,self.c_price,self.c_period))
python=Course('python全栈开发',1900,'5mons')
linux=Course('linux架构师',900,'3mons')
stu1=OldboyStudent('刘二蛋',38,'male')
stu1.courses.append(python)
stu1.courses.append(linux)
stu1.tell_all_course()
tea1=OldboyTeacher('egon',18,'male',10)
tea1.courses.append(python)
tea1.tell_all_course()
三大特性之二:多态
多态与多态性
'''
1. 什么是多态
多态指的是同一种/类事物的不同形态
2. 为何要用多态
多态性:在多态的背景下,可以在不用考虑对象具体类型的前提下而直接使用对象
多态性的精髓:统一
3. 如何用多态
'''
'''
class Animal:
def speak(self):
pass
class People(Animal):
def shuo(self):
print('say hello')
class Dog(Animal):
def jiao(self):
print('汪汪汪')
class Pig(Animal):
def chang(self):
print('哼哼哼')
obj1=People()
obj2=Dog()
obj3=Pig()
# obj1.speak()
# obj2.speak()
# obj3.speak()
def speak(animal):
animal.speak()
speak(obj1)
speak(obj2)
speak(obj3)
s1='hello'
l1=[1,2,3]
t1=(1,2)
# changdu(s1)
# size(l1)
# kuangdu(t1)
print(len(s1)) #s1.__len__()
print(len(l1)) #l1.__len__()
print(len(t1)) #t1.__len__()
'''
import abc
class Animal(metaclass=abc.ABCMeta):
@abc.abstractmethod
def speak(self):
pass
@abc.abstractmethod
def run(self):
pass
class People(Animal):
def speak(self):
print('say hello')
def run(self):
pass
class Dog(Animal):
def speak(self):
print('汪汪汪')
def run(self):
pass
class Pig(Animal):
def speak(self):
print('哼哼哼')
def run(self):
pass
obj1=People()
obj2=Dog()
obj3=Pig()
class Disk:
def read(self):
print('Disk read')
def write(self):
print('Disk write')
class Memory:
def read(self):
print('Mem read')
def write(self):
print('Mem write')
class Cpu:
def read(self):
print('Cpu read')
def write(self):
print('Cpu write')
obj1=Disk()
obj2=Memory()
obj3=Cpu()
obj1.read()
obj2.read()
obj3.read()
三大特性之二:封装
封装
'''
1. 什么是封装
装:往容器/名称空间里存入名字
封:代表将存放于名称空间中的名字给藏起来,这种隐藏对外不对内
2. 为何要封装
封数据属性:???
封函数属性:???
3. 如何封装
在类内定义的属性前加__开头(没有__结果)
总结:
1. __开头的属性实现的隐藏仅仅只是一种语法意义上的变形,并不会真的限制类外部的访问
2. 该变形操作只在类定义阶段检测语法时发生一次,类定义阶段之后新增的__开头的属性并不会变形
3. 如果父类不想让子类覆盖自己的属性,可以在属性前加__开头
'''
class Foo:
__x=111
__y=222
def __init__(self,name,age):
self.__name=name
self.__age=age
def __func(self):
print('func')
def get_info(self):
print(self.__name,self.__age,self.__x)
obj=Foo('egon',18)
obj.__sex='male'
class Foo:
def __f1(self):
print('Foo.f1')
def f2(self):
print('Foo.f2')
self.__f1()
class Bar(Foo):
def __f1(self):
print('Bar.f1')
obj=Bar()
'''
Foo.f2
Foo.f1
'''
class People:
def __init__(self,name,age):
self.__name=name
self.__age=age
def tell_info(self):
print('<name:%s age:%s>' %(self.__name,self.__age))
def set_info(self,name,age):
if type(name) is not str:
print('名字必须是str类型傻叉')
return
if type(age) is not int:
print('年龄必须是int类型傻叉')
return
self.__name=name
self.__age=age
obj=People('egon',18)
obj.set_info('EGON','18')
obj.tell_info()
class ATM:
def __card(self):
print('插卡')
def __auth(self):
print('用户认证')
def __input(self):
print('输入取款金额')
def __print_bill(self):
print('打印账单')
def __take_money(self):
print('取款')
def withdraw(self):
self.__card()
self.__auth()
self.__input()
self.__print_bill()
self.__take_money()
a=ATM()
a.withdraw()
property
class People:
def __init__(self,name,weight,height):
self.name=name
self.weight=weight
self.height=height
@property
def bmi(self):
return self.weight / (self.height ** 2)
obj=People('egon',80,1.83)
obj.height=1.85
obj.weight=75
print(obj.bmi())
print(obj.bmi)
class People:
def __init__(self,name):
self.__name=name
@property
def name(self):
return '<名字:%s>' %self.__name
@name.setter
def name(self,obj):
if type(obj) is not str:
print('name必须为str类型')
return
self.__name=obj
@name.deleter
def name(self):
del self.__name
obj=People('egon')
class People:
def __init__(self,name):
self.__name=name
def get_name(self):
return '<名字:%s>' %self.__name
def set_name(self,obj):
if type(obj) is not str:
print('name必须为str类型')
return
self.__name=obj
def del_name(self):
del self.__name
name=property(get_name,set_name,del_name)
obj=People('egon')
print(obj.name)
obj.name='EGON'
obj.name=123
print(obj.name)
del obj.name
print(obj.__dict__)
绑定方法与非绑定方法
class Foo:
def f1(self):
print(self)
@classmethod
def f2(cls):
print(cls)
@staticmethod
def f3(x,y):
print('f3',x+y)
obj=Foo()
print(obj.f1)
obj.f1()
print(Foo.f2)
Foo.f2()
print(obj.f2)
obj.f2()
print(Foo.f3)
print(obj.f3)
Foo.f3(1,2)
obj.f3(3,4)
import settings
class MySql:
def __init__(self, ip, port):
self.id = self.create_id()
self.ip = ip
self.port = port
def tell_info(self):
print('<id:%s ip:%s port:%s>' % (self.id, self.ip, self.port))
@classmethod
def from_conf(cls):
return cls(settings.IP, settings.PORT)
@staticmethod
def create_id():
import uuid
return uuid.uuid4()
obj2 = MySql.from_conf()
obj2.tell_info()
面向对象串讲
'''
1 类与对象
对象是特征与技能的结合体,而类则是一些列对象相同特征与技能的结合
对象本质是一个容器/名称空间:用来存放对象特有的属性
类的本质也是一个容器/名称空间:用来存放对象相同的属性
类有两种用途:
1. 当容器去用
类的数据属性
类的函数属性
2. 调用类的过程称为实例化,结果就是对象
实例化时方式两件事:
1. 先产生一个空对象
2. 触发__init__(空对象,arg1,arg2,...)
2 继承与派生
1. 什么是继承
继承是一种新建类的方式,新建的类称之为子类/派生类,被继承类称之为父类/超类/基类
继承描述的是一种遗传的关系,特点:
1. 子类可以遗传/重用父类的属性(减少代码冗余)
2. 一个子类可以同时继承多个父类
3. 在继承的背景下,类分为新式类与经典类
子类如何重用父类属性?
在继承背景下属性的查找顺序???
新式类vs经典类
2. 为何要用继承
解决类与类之间代码冗余的问题
3. 如何继承
class Foo:
pass
class Bar(Foo):
x=1
obj=Bar()
4. 在子类派生新方法中重用父类功能的两种方式:
方式一:指名道姓地访问某一个类的函数
特点:
1. 与继承无关
2. 没有自动传值的效果
方式二:super(自己的类名,self)会得到一个特殊的对象,该对象专门用来访问"父类"中的属性,完全参照mro列表
特点:
1. 严格依赖继承,完全参照mro列表
2. 有自动传值的效果
3 组合
1. 什么是组合
组合指的是一个对象拥有某一个属性,该属性的值是来自于另外一个类的对象
class OldboyStudent:
pass
class OldboyTeacher:
pass
class Course:
pass
stu=OLdboyStudent()
tea=OLdboyTeacher()
obj=Course()
stu.attr=obj
tea.attr=obj
2. 为何要用组合
解决类与类之间代码冗余的问题
4 多态
多态指的是同一种事物的多种形态,
多态性指的是可以在不用考虑对象具体类型前提下而直接使用对象
多态的精髓就是"统一"二字
python崇尚鸭子类型
5 封装
装
封
'''
class Foo:
x=1
def __init__(self,name,age):
self.name=name
self.age=age
def f1(self):
print('run')
obj=Foo('egon',18)
class A:
def f1(self):
print('A.f1')
super().f2()
class B:
def f2(self):
print('B.f2')
class C(A,B):
def f2(self):
print('C.f2')
obj=C()
print(C.mro())
obj.f1()
'''
A.f1
'''
class People:
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
class Teacher(People):
def __init__(self,name,age,sex,level):
super().__init__(name,age,sex)
self.level=level
obj=Teacher('egon',18,'male',18)
print(obj.__dict__)
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· SQL Server 内存占用高分析
· .NET Core GC计划阶段(plan_phase)底层原理浅谈
· .NET开发智能桌面机器人:用.NET IoT库编写驱动控制两个屏幕
· 用纯.NET开发并制作一个智能桌面机器人:从.NET IoT入门开始
· 一个超经典 WinForm,WPF 卡死问题的终极反思
· 支付宝事故这事儿,凭什么又是程序员背锅?有没有可能是这样的...
· 在线客服系统 QPS 突破 240/秒,连接数突破 4000,日请求数接近1000万次,.NET 多
· C# 开发工具Visual Studio 介绍
· 在 Windows 10 上实现免密码 SSH 登录
· C#中如何使用异步编程