Python的基础语法及使用
随着时代的日新月异,Python也越来越受人们的重视,鉴于此,我整理了一些关于Python的基础语法及如何使用这些语法的内容,供大家参阅,文中内容如有不妥之处,欢迎大家提出,本文以例子为主,叙述居少。
一、Python的简介
二、Python的特点
三、Python的基本语法及使用
3.1 数据类型
** Python中,所有标识符可以包括英文、数字以及下划线(_),但不能以数字开头,区分大小写
** 以下划线开头的标识符有特殊意义。如:_foo 不能直接访问,需通过类提供的接口进行访问
** 在 python 中,变量是没有类型的,如:
a=[1,2,3]
a="Runoob"
[1,2,3] 是 List 类型,"Runoob" 是 String 类型,而变量 a 是没有类型,它仅仅是一个对象的引用(一个指针),可以指向 List 类型对象,也可以指向 String 类型对象。
** Python3有六个标准的数据类型:
Number(数字)
String(字符串)
List(列表)
Tuple(元组)
Dictionary(字典)
Set(集合,Python3新加的)
3.2 数字
int(有符号整型)
float(浮点型)
complex(复数:由实数和虚数构成,用a + bj,或complex(a,b)来表示)
# long(长整型,注:在Python3里被去除了)
例如:
a=100
print(a)
b=1.23
print(b)
c=10+2j #复数(实数+虚数)
print(c)
3.3 字符串
** 其中三引号可以由多行组成
例1:
a = 'word'
b = "这是一个句子"
c = '''这是一个段落,
包含了多个语句'''
print(a,b,'\n',c) # 中间用空格间隔
例2:
str = 'Hello World!'
print(str)
print(str[0]) # 输出字符串中的第一个字符
print(str[2:5]) # 输出字符串中第三个至第五个(不包含第5个)之间的字符串
print(str[2:]) # 输出从第三个字符开始的字符串
print(str * 2) # 输出字符串两次
print(str + "TEST") # 输出连接的字符串
#print(str+1) # 错误,不可以是非字符串类型(和java不一样)
** 这种方法效率低
# python中字符串是不可变的类型,使用 + 连接两个字符串时会生成一个新的字符串,生成新的字符串
# 就需要重新申请内存,当连续相加的字符串很多时(a+b+c+d+e+f+...) ,效率低下就是必然的了
print('a' + 'b' + 'c')
# 略复杂,但对多个字符进行连接时效率高,只会有一次内存的申请。
# 如果是对list的字符进行连接的时候,这种方法是首选
listStr = ['a', 'b', 'c']
s = ''.join(listStr)
print(s)
# 字符串格式化,这种方法非常常用
print('%s%s%s' % ('a', 'b', 'c'))
print( 'Hello: %s %s %s' % ('aaa', 100, 22.3) )
PS:多个变量同时赋值
a,b,c=1,2.2,"abc"
print(a,b,c)
3.4 列表
列表支持字符,数字,字符串,还可以包含列表(即嵌套)
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
print(list) # 输出完整列表
list[0]='aaa'
print(list[0]) # 输出列表的第一个元素
print(list[1:3]) # 输出第二个至第三个的元素,不包括第三个
print(list[2:]) # 输出从第三个开始至列表末尾的所有元素
print(tinylist * 2) # 列表元素重复两次
print(list + tinylist) # 将两个列表合并
3.5 元组
** 元组是另一种数据类型,类似于List(列表)。
** 元组用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值,相当于只读列表。
tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')
print(tuple) # 输出完整元组
# tuple[0]='aaa' # 错误
print(tuple[0]) # 输出元组的第一个元素
print(tuple[1:3]) # 输出第二个至第三个的元素
print(tuple[2:]) # 输出从第三个开始至列表末尾的所有元素
print(tinytuple * 2) # 输出元组两次
print(tuple + tinytuple) # 打印组合的元组
3.6 字典
dict['one'] = "This is one"
dict[2] = "This is two"
tinydict = {'name': 'john','code':6734, 'dept': 'sales'}
print(dict['one']) # 输出键为'one' 的值
print(dict[2]) # 输出键为 2 的值
print(tinydict) # 输出完整的字典
print(tinydict.keys()) # 输出所有键
print(tinydict.values()) # 输出所有值
3.7 set
student = {'Tom','Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
print(student) #重复的元素被自动去掉
if('Rose' in student) :
print('Rose 在集合中')
else :
print('Rose 不在集合中')
# set可以进行集合运算
a = set('abcde')
b = set('abcfg')
print(a)
print(b)
print(a - b) # a和b的差集
print(a | b) # a和b的并集
print(a & b) # a和b的交集
print(a ^ b) # a和b中不同时存在的元素
3.8 bytes类型
b = b'china'
print(b[0]) #打印出的是ascii码
print(type(b)) #查看类型
s = b.decode() #转换为字符串
print(s)
b1 = s.encode() #转换为bytes类型
print(b1)
3.9 可变与不变
不可变类型:变量赋值 a=5 后再赋值 a=10,这里实际是新生成一个 int 值对象 10,再让 a 指向它,而 5 被丢弃,不是改变a的值,相当于新生成了a。
可变类型:变量赋值 list=[1,2,3,4] 后再赋值 list[2]=5 则是将llist的第三个元素值更改, list本身没有动,只是其内部的一部分值被修改了。
3.10 运算符
print(10//3) #3 求整数商
print(1/2) #0.5,和其他语言有所不同
a=100
a+=1 #没有a++
print(a)
关系运算符: > < == != (<>在Python3中不支持) >= <=
3.11 逻辑运算符
a = 10
b = 20
if (a and b):
print("1 - 变量 a 和 b 都为 true")
else:
print("1 - 变量 a 和 b 有一个不为 true")
if (a or b):
print("2 - 变量 a 和 b 都为 true,或其中一个变量为 true")
else:
print("2 - 变量 a 和 b 都不为 true")
# 修改变量 a 的值
a = 0
if (a and b):
print("3 - 变量 a 和 b 都为 true")
else:
print("3 - 变量 a 和 b 有一个不为 true")
if (a or b):
print("4 - 变量 a 和 b 都为 true,或其中一个变量为 true")
else:
print("4 - 变量 a 和 b 都不为 true")
if not (a and b):
print("5 - 变量 a 和 b 都为 false,或其中一个变量为 false")
else:
print("5 - 变量 a 和 b 都为 true")
3.12 成员运算符
a = 1
b = 20
list = [1, 2, 3, 4, 5];
if (a in list):
print("1 - 变量 a 在给定的列表中 list 中")
else:
print("1 - 变量 a 不在给定的列表中 list 中")
if (b not in list):
print("2 - 变量 b 不在给定的列表中 list 中")
else:
print("2 - 变量 b 在给定的列表中 list 中")
3.13 身份运算符
# is 与 == 区别:is 用于判断两个变量引用对象是否为同一个, == 用于判断引用变量的值是否相等
a = 20
b = 20
print(a is b)
print(a is not b)
# 修改变量 b 的值
b = 30
print(a is b)
print(a is not b)
3.14 代码组
** Python最具特色的就是用缩进来写模块
** 缩进相同的一组语句构成一个代码块,我们称之代码组
** 像if、while、def和class等首行以关键字开始,以冒号结束,该行之后的一行或多行代码构成"代码组"
** 我们将首行及后面的代码组称为一个"子句"(clause)
** 缩进的空白数量是可变的,但是所有代码块语句必须包含相同的缩进空白数量,这个必须严格执行!!!
例如:
if expression :
suite #代码组
elif expression :
suite
else :
suite
例如:(注意:没有严格缩进,在执行时会报错)
** 通过coding属性支持中文(在不支持中文时,加上该句)
** 下面代码会报缩进错误IndentationError
#!/usr/bin/python
# -*- coding: UTF-8 -*-
if True:
print("aaa")
print("True")
else:
print("bbb")
print("False") #注意缩进,只要对齐就行,至于用空格还是用tab对齐没区别
PS:
有些环境下,tab和空格不可以混用,有些环境下可以。
因此建议在每个缩进层统一使用'单个制表符'、'两个空格'或'四个空格',尽量不要混用,以避免不必要的麻烦。
3.15 while、continue、break、for、pass
count = 0
while count < 10 :
#while (count < 10) : #也可以
print('The count is:', count)
count = count + 1
====while … else====
** 循环条件为false时,执行else语句块,只执行一次
count = 0
while count < 5:
print(count, " is less than 5")
count = count + 1
else:
print(count, " is not less than 5")
====continue====
i = 1
while i < 10:
i += 1
if i%2!=0 : # 非双数时跳过输出
continue
print(i) # 输出双数2、4、6、8、10
====break====
i = 1
while True :
print(i)
i += 1
if i > 10: # 当i大于10时跳出循环
break
====for====
for letter in 'Python' :
print('当前字母 :', letter)
----------------------------------
fruits = ['banana', 'apple', 'mango']
for fruit in fruits :
print('当前水果 :', fruit)
----------------------------------
** 通过序列索引迭代
fruits = ['banana', 'apple', 'mango']
for index in range(len(fruits)):
#for index in range(3): #效果相同,即(1,2,3)
print('当前水果 :', fruits[index])
====for...else====
for num in range(2,10): # 迭代 2 到 10 之间的数字
for i in range(2,num): # 根据因子迭代
if num%i == 0: # 确定第一个因子
j=num/i # 计算第二个因子
print('%d 等于 %d * %d' % (num,i,j))
break # 跳出当前循环
else: # 循环的 else 部分
print(num, '是一个质数')
** pass语句不做任何事情,一般用做占位
for letter in 'Python':
if letter == 'h':
pass
print('这是 pass 块')
else:
print('当前字母 :', letter)
四、函数
** 函数内容以冒号起始,并且缩进
** 函数的第一行语句可以是字符串,用于函数说明
** return [表达式] 结束函数,不带返回值表达式的相当于返回None
语法:
def functionname( parameters ):
"函数_文档字符串"
function_suite
return [expression]
4.1 参数传递
4.1.1 不可变类型
def ChangeInt( a ):
a = 10
b = 2
ChangeInt(b)
print(b) # 结果是 2
4.1.2 可变类型
对于可变类型:类似 c++ 的引用传递,如 列表,字典。如 fun(list),则是将 list 真正的传过去,修改后fun外部的list也会受影响。
def changeme(mylist):
mylist.append(50);
print(mylist)
return
mylist = [10, 20, 30];
changeme(mylist);
print(mylist)
PS:
python中一切都是对象,严格意义我们不能说值传递还是引用传递,我们应该说传不可变对象和传可变对象。
4.1.3 通过参数名赋参
def printinfo(name, age):
print("Name: ", name)
print("Age ", age)
return;
printinfo(age=50, name="miki");
4.1.4 默认参数
def printinfo(name, age=35):
print("Name: ", name)
print("Age ", age)
return;
printinfo(age=50, name="miki");
printinfo("miki");
4.1.5 变长参数
def printinfo(arg1, *vartuple):
print("输出: ")
print(arg1)
for x in vartuple:
print(x)
return;
printinfo(10);
printinfo(20,30,40,50);
4.2 lambda函数
lambda主体是一个表达式,而不是一个代码块,仅仅能在lambda表达式中封装有限的逻辑进去
lambda函数拥有自己的命名空间,且不能访问自有参数列表之外或全局命名空间里的参数
Python仅仅将 lambda 定位成一个辅助用的短函数,所以lambda只能写一行,不能赋值,内部也不能定义等
sum = lambda arg1, arg2: arg1 + arg2
print(sum(10, 20))
def makeSum():
sum = lambda arg1, arg2: arg1 + arg2
return sum
f = makeSum()
print(f(10, 20))
4.3 返回值
total = arg1 + arg2
print("函数内 : ", total)
return total
total = sum(10, 20)
print("函数外 : ", total)
4.4 函数类型参数
def add(x, y, f):
return f(x) + f(y)
print(abs(-3)) #绝对值
print(add(-3, 5, abs)) #当函数作为参数时,不可以加()
4.5 全局变量和局部变量
定义在函数内部的变量拥有一个局部作用域,定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问,而全局变量可以在整个程序范围内访问。
total = 0; # 这是一个全局变量
def sum(arg1, arg2):
#total = arg1 + arg2; #注意此处注解取消后的不同,若有同名变量的话,局部变量的优先级高于全局变量
print(total)
return total;
sum(10, 20);
print(total)
4.6 global
** global:将函数内变量定义为全局变量,可以通过定义为全局变量,实现在函数内部改变变量值
#globvar = 0 #此处globvar的定义可有可无
def set_globvar_to_one():
global globvar # 使用 global 声明全局变量
globvar = 1
def print_globvar():
print(globvar) # 没有使用 global
set_globvar_to_one()
print(globvar) # 输出 1
print_globvar() # 输出 1,函数内的 globvar 已经是全局变量
4.7 模块
Python模块(Module),是一个 Python 文件,以 .py 结尾,包含了 Python 对象定义和Python语句。
模块让你能够有逻辑地组织你的 Python 代码段。
把相关的代码分配到一个模块里能让你的代码更好用,更易懂。
模块能定义函数,类和变量,模块里也能包含可执行的代码。
----support.py-----------
#support模块
def print_func( s ):
print("Hello : ", s)
return
----hello.py-------------
# 方式一
import support
support.print_func("Tom")
# 方式二
from support import print_func
print_func("Tom")
# 方式三
from support import *
print_func("Tom")
4.8 输入与类型转换
import sys
# 输入一个字符串
#s=sys.stdin.readline()
#print(s) #输入字符串的末尾会多出一个字符'\n',例如,输入的是'abc',得到的是'abc\n',因此长度会加1
s='100'
a=int(s)
b=float(a)
b+=1
s=str(b)
print(s)
4.9 命名空间和作用域
变量是拥有匹配对象的名字(标识符)。命名空间是一个包含了变量名称们(键)和它们各自相应的对象们(值)的字典。
一个Python表达式可以访问局部命名空间和全局命名空间里的变量。如果一个局部变量和一个全局变量重名,则局部变量会覆盖全局变量。
每个函数都有自己的命名空间。类的方法的作用域和通常函数的一样。
4.10 包
简单来说,包就是文件夹,该文件夹下必须存在 __init__.py 文件, 其内容可以为空,__int__.py用于标识当前文件夹是一个包
目录结构如下:
hello.py
mypackage(文件夹)
|-- __init__.py
|-- runoob1.py
|-- runoob2.py
runoob1.py:
def f1():
print("I'm in runoob1")
runoob2.py
def f2():
print("I'm in runoob2")
hello.py:
from mypackage.runoob1 import f1
from mypackage.runoob2 import f2
f1()
f2()
import sys
s = sys.stdin.readline()
print(s)
4.11 异常处理
try:
print(1/0)
except IOError:
print("IOError")
except ZeroDivisionError:
print("ZeroDivisionError")
else: #无异常时
print("esle")
finally:
print("finally")
五、类
** 类方法必须包含参数self,且为第一个参数
class Employee:
'所有员工的基类' #第一行可以用字符串来做说明
#empCount是一个类变量,在这个类的所有实例之间共享,使用Employee.empCount来访问
empCount = 0
#构造器
#self代表类的实例,在定义时必须有,在调用时不必传值
#参数为属性
def __init__(self, name, salary):
self.name = name
self.salary = salary
Employee.empCount += 1
def displayCount(self): #self不可以省略
print("Total Employee %d" % Employee.empCount)
def displayEmployee(self):
print("Name : ", self.name, ", Salary: ", self.salary)
a=Employee("zhangsan",5000)
print(Employee.empCount,a.name,a.salary)
a.age=26 #添加属性
print(a.age)
del a.age #删除属性
#print(a.age)
b=Employee("lisi",5000)
print(Employee.empCount,b.name,b.salary)
b.displayCount()
b.salary=6000
b.displayEmployee()
print(b)
5.1 关于self
self 代表的是类的实例,代表当前对象的地址,而 runoob.__class__ 指向类
self 不是关键字,换成其他也可以,如:runoob
class Test:
def myprint(runoob):
print(runoob)
print(runoob.__class__)
t = Test()
t.myprint()
5.2 内置类属性
__doc__ : 类的文档字符串
__name__ : 类名
__module__: 类定义所在的模块 (类的全名是'__main__.className',如果类位于一个导入模块mymodule中,那么__module__即为 mymodule)
__bases__ : 类的所有父类构成元素(包含了一个由所有父类组成的元组)
__dict__ : 类的属性(包含一个字典,由类的数据属性组成)
class Employee:
'雇员类'
empCount = 0
print("Employee.__doc__:", Employee.__doc__)
print("Employee.__name__:", Employee.__name__)
print("Employee.__module__:", Employee.__module__)
print("Employee.__bases__:", Employee.__bases__)
print("Employee.__dict__:", Employee.__dict__)
5.3 python对象销毁(垃圾回收)
Python 使用了引用计数这一简单技术来跟踪和回收垃圾
在 Python 内部记录着所有使用中的对象各有多少引用
当对象被创建时, 就创建了一个引用计数, 当这个对象不再需要时, 也就是说, 这个对象的引用计数变为0 时, 它被垃圾回收。但是回收不是"立即"的, 由解释器在适当的时机,将垃圾对象占用的内存空间回收
如:
a = 40 # 创建对象 <40>
b = a # 增加引用, <40> 的计数
c = [b] # 增加引用. <40> 的计数
del a # 减少引用 <40> 的计数
b = 100 # 减少引用 <40> 的计数
c[0] = -1 # 减少引用 <40> 的计数
5.4 析构函数
** 析构函数__del__在对象销毁的时候被调用
class Point:
def __init__(self, x=0, y=0):
self.x = x
self.y = y
def __del__(self):
class_name = self.__class__.__name__
print(class_name, "销毁")
pt1 = Point()
pt2 = pt1
pt3 = pt1
print(id(pt1), id(pt2), id(pt3)) #打印对象的id
del pt1
del pt2
del pt3
5.5 继承
基类构造器(__init__())不会被自动调用
Python先在本类中查找调用的方法,找不到才去基类中找
如果在继承元组中列了一个以上的类,那么它就被称作"多重继承"
class Parent: #父类
parentAttr = 100
def __init__(self):
print("调用父类构造函数")
def parentMethod(self):
print('调用父类方法')
def setAttr(self, attr):
Parent.parentAttr = attr
def getAttr(self):
print("父类属性 :", Parent.parentAttr)
class A:
a=0
class Child(Parent,A): #子类,多重继承
def __init__(self):
print("调用子类构造方法")
def childMethod(self):
print('调用子类方法')
c = Child() # 实例化子类
c.childMethod() # 调用子类的方法
c.parentMethod() # 调用父类方法
c.setAttr(200) # 再次调用父类的方法 - 设置属性值
c.getAttr() # 再次调用父类的方法 - 获取属性值
5.6 方法重写
def myMethod(self):
print('调用父类方法')
class Child(Parent): # 定义子类
def myMethod(self):
print('调用子类方法')
c = Child() # 子类实例
c.myMethod() # 子类调用重写方法
5.7 运算符重载
** 注:Python不支持函数重载
常见重载方法:
Method Overloads Call for
------ ---------- ---------
__init__ 构造函数 X=Class()
__del__ 析构函数 对象销毁
__add__ + X+Y,X+=Y
__sub__ - X-Y,X-=Y
__or__ | X|Y,X|=Y
__repr__ 打印转换 print X,repr(X)
__str__ 打印转换 print X,str(X)
__call__ 调用函数 X()
__getattr_ 限制 X.undefine
__setattr__ 取值 X.any=value
__getitem__ 索引 X[key],
__len__ 长度 len(X)
__cmp__ 比较 X==Y,X<Y
__lt__ 小于 X<Y
__eq__ 等于 X=Y
__radd__ Right-Side + +X
__iadd__ += X+=Y
__iter__ 迭代 For In
5.8 加号重载
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(6, 1)
print(v1 + v2)
5.9 减号重载
class Number:
def __init__(self, start):
self.data = start #添加属性
def __sub__(self, other): # minus method
return Number(self.data - other)
number = Number(30)
y = number - 10
print(y.data) #20
5.10 私有
** 私有属性:两个下划线开头,不能在类的外部使用,类内部使用时用self.__XXX
但可以使用 object._className__attrName来访问私有属性
私有方法:两个下划线开头,不能在类的外部调用,类内部调用时用self.__private_methods
class JustCounter:
__secretCount = 0 # 私有变量
publicCount = 0 # 公有变量
def count(self):
self.__secretCount += 1
self.publicCount += 1
print(self.__secretCount)
counter = JustCounter()
counter.count()
print(counter.publicCount)
#print(counter.__secretCount) #错误
print(counter._JustCounter__secretCount)
补充:单下划线、双下划线、头尾双下划线说明:
1 __XXX__: 定义的是特殊方法,如 __init__() 之类
2 _foo: 以单下划线开头的表示的是 protected 类型的变量,
即保护类型只能允许其本身与子类进行访问,不能用于 from module import *
3 __foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了
Python的基础语法及使用相关推荐
- python菜鸟基础教程-python基础菜鸟教程,Python的基础语法
原标题:python基础菜鸟教程,Python的基础语法 什么是Python?Python是一门简单直观的编程语言,并且目前是开源的,可以方便任何人使用. Python的开发哲学:用一种方法,最好是只 ...
- python编程基础语法-Python编程基础语法快速入门
1. 课程咨询加老师助理微信:助理1微信: chenjinglei88 ,助理2微信: omf6757 2. 决定购买并想得到陈敬雷老师亲自指导(课程或自己项目难题均可)加老师微信: chenjing ...
- 第二节 -- python的基础语法
python的基础语法 编码:在python2中,默认编码是ASCII:在python3中,默认源码文件以UTF-8编码,所有字符串都是Unicode字符串.可通过输入 # -*- coding: 编 ...
- python 判断列表所有元素是否为某个值_这应该是最详细的Python入门基础语法总结!...
这应该是最详细的Python入门基础语法总结! 这应该是最详细的Python入门基础语法总结! 定义变量,使用变量 input 用户自己输入值 print 打印值 可以输出多个变量 %d|%s 用于输 ...
- python基础教程菜鸟教程-python基础菜鸟教程,Python的基础语法
原标题:python基础菜鸟教程,Python的基础语法 什么是Python?Python是一门简单直观的编程语言,并且目前是开源的,可以方便任何人使用. Python的开发哲学:用一种方法,最好是只 ...
- 第二章:python必备基础语法
文章目录 第二章 python必备基础语法 一.变量 1.1 什么是变量?有什么用处? 1.2 如何声明一个变量(即定义变量)? 1.3 变量的命名规则及风格 1.4 变量值的三大特性 作业: 1.5 ...
- python编程语法教程-Python编程基础语法快速入门
1. 课程咨询加老师助理微信:助理1微信: chenjinglei88 ,助理2微信: omf6757 2. 决定购买并想得到陈敬雷老师亲自指导(课程或自己项目难题均可)加老师微信: chenjing ...
- python的基础语法(组合数据类型)
目录 python的基础语法(组合数据类型) 一,list列表 1 什么是列表? 2 列表怎么声明? 3 列表的操作 二,tuple元组 1. 什么是元组|元组的特点 2. 元组的声明 3. 元组的操 ...
- Python的零基础超详细讲解(第三天)-Python的基础语法
多行语句 Python 通常是一行写完一条语句,但如果语句很长,我们可以使用反斜杠 \ 来实现多行语句,例如: duohang = item_one + \item_two + \item_three ...
最新文章
- 编写程序创建一个通讯录文件,在其中存入10位同学的姓名、年龄、电话号码,并在屏幕上输出第2、4、6、8、10位同学的信息
- TI-BLE协议栈的GAP
- php里注册管理员账号,WordPress中创建用户角色的相关PHP函数使用详解
- 如何一步一步用DDD设计一个电商网站(十三)—— 领域事件扩展
- iframe 覆盖父页面_一次iframe子页面与父页面的通信
- 运算放大器基本公式_运算放大器 - 产生的背景和解决的问题
- 摆脱困境:在DbUnit数据集中使用空值
- python numpy array中维度的区别 array.shape
- 【廖雪峰官方网站/Java教程】多线程(2)
- 数字图像学笔记——8. 几种常见的空间滤波器(均值滤波器、中值滤波器)
- 映美精LoadDeviceStateFromFile问题
- cursor游标讲解
- 图像处理实践 | 水果图像的识别与分类
- Vim中文本全部选中
- mysql error 364_MySQL事务未提交致使整个表锁死
- 处理HttpWebRequest访问https有安全证书的问题
- mysql中高阶玩法系列(九)
- C++无法在头文件中定义string类数据
- 卷帘曝光和全局曝光的差别
- 设置silverlight启用剪贴板的功能
热门文章
- 错误码:28,错误信息:没有足够的存储空间 解决方法
- 草木有本心,何求美人折
- 用Python做数据分析之数据筛选及分类汇总
- VM-CentOS7.6-启动时assuming drive cache:write through
- SVG (SVG的概念 、SVG 实例 、SVG 在HTML中 、SVG 矩形 、SVG 圆形 、SVG 椭圆 、SVG 直线 、SVG 多边形、svg验证码 )
- mysql lsl_GitHub - LSL-Git/MyBatis_Dynamic_SQL: mybatis 动态SQL使用
- JDK内置并发框架AQS对CLH锁的优化
- linux管道通信原理
- 基于Java的网上商城系统
- template-模板完全特化