set集合

集合是一个无序的,不重复的元素集合。

集合的创建:

name_set = {'tom','jerry','alex','rose'}

name_set = set(['tom','jerry','alex','rose'])

集合的方法:

  • 添加一个元素

    def add(self, *args, **kwargs):

name_set.add('jack')

name_set

{'alex', 'tom', 'jerry', 'jack', 'rose'}

```
  • 清除集合所有元素

    def clear(self, *args, **kwargs):

name_set = {'tom','jerry','alex','rose'}

name_set.clear()

print(name_set)

set()

```
  • 浅拷贝

    def copy(self, *args, **kwargs):

name_set = {'tom','jerry','alex','rose'}

name_set_copy = name_set.copy()

name_set_copy

{'tom','jerry','alex','rose'}

```
  • 集合A中存在,集合B中不存在的元素

    def difference(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

B_set = {'jerry','jack','rose','eric'}

A_set.difference(B_set)

{'tom'}

```
  • 从当前集合中删除和B中相同的元素

    def difference_update(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

B_set = {'jerry','jack','rose','eric'}

A_set.difference_update(B_set)

A_set

{'tom'}

```
  • 移除指定元素,不存在不保错

    def discard(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

A_set.discard('eric')

A_set

{'tom','jerry','jack','rose'}

```
  • 移除指定元素,不存在报错

    def remove(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

A_set.remove('eric')

Traceback (most recent call last):

File "", line 1, in

A_set.remove('eric')

KeyError: 'eric'

```
  • 随机移出元素,当集合为空时报错

    def pop(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

A_set.pop()

'jack'

A_set.pop()

'jerry'

A_set.pop()

'tom'

A_set.pop()

'rose'

A_set.pop()

Traceback (most recent call last):

File "", line 1, in

A_set.pop()

KeyError: 'pop from an empty set'

```
  • 两个集合的交集

    def intersection(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

B_set = {'jerry','jack','rose','eric'}

A_set.intersection(B_set)

{'jack', 'rose', 'jerry'}

```
  • 取A,B两个集合的交集并将交集更新到A中

    def intersection_update(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

B_set = {'jerry','jack','rose','eric'}

A_set.intersection_update(B_set)

A_set

{'jack', 'rose', 'jerry'}

```
  • A,B两个集合如果没有交集,返回True,否则返回False

    def isdisjoint(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

B_set = {'jerry','jack','rose','eric'}

A_set.isdisjoint(B_set)

False

```
  • 集合B是否是集合A的子序列

    def issubset(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

B_set = {'jerry','jack','rose'}

B_set.issubset(A_set)

True

```
  • 集合A是否是集合B的父序列

    def issuperset(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

B_set = {'jerry','jack','rose'}

A_set.issuperset(B_set)

True

```
  • 对称差集

    def symmetric_difference(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

B_set = {'jerry','jack','rose','eric'}

A_set.symmetric_difference(B_set)

{'tom', 'eric'}

```
  • 对称差集,并更新到A中

    def symmetric_difference_update(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

B_set = {'jerry','jack','rose','eric'}

A_set.symmetric_difference_update(B_set)

A_set

{'eric', 'tom'}

```
  • 并集

    def union(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

B_set = {'jerry','jack','rose','eric'}

A_set.union(B_set)

{'jerry', 'jack', 'eric', 'rose', 'tom'}

```
  • 更新

    def update(self, *args, **kwargs):

A_set = {'tom','jerry','jack','rose'}

B_set = {'jerry','jack','rose','eric'}

A_set.update(B_set)

A_set

{'jerry', 'jack', 'eric', 'rose', 'tom'}

```

函数

函数定义

def 函数名(参数):
...
函数体
...
返回值
  • def:表示函数的关键字
  • 函数名:函数的名称,日后根据函数名调用函数
  • 函数体:函数中进行一系列的逻辑计算,如:发送邮件、计算出 [11,22,38,888,2]中的最大数等...
  • 参数:为函数体提供数据
  • 返回值:当函数执行完毕后,可以给调用者返回数据。

函数返回值:

默认情况下如果用户不加函数返回值函数会返回None,关键字是return

例子:

def 发送短信():
发送短信的代码...
if 发送成功:
return True
else:
return False while True:
# 每次执行发送短信函数,都会将返回值自动赋值给result
# 之后,可以根据result来写日志,或重发等操作 result = 发送短信()
if result == False:
记录日志,短信发送失败...

函数的参数

  • 普通参数
  • 默认参数
  • 动态参数

例子:

普通参数:

#name,age叫做形参(形式参数)
def func(name,age):
print name
#'tom',18叫做实参(实际参数)
func('tom',18)

默认参数:

def func(name, age = 18):

    print("%s:%s" %(name,age))

# 普通参数
func('tom', 19)
# 使用默认参数
func('jerry') 程序结果:
tom:19
jerry:18
注:默认参数需要放在参数列表最后

动态参数:

def func(*args):
print args # 可将多个参数传至args,args = (11,33,4,4454,5)
func(11,33,4,4454,5) # 如果传li的话arg = ([11,2,2,3,3,4,54],),*li的话args = (11,2,2,3,3,4,54)
li = [11,2,2,3,3,4,54]
func(*li)
def func(**kwargs):
print kargs # kargs = {'name':'tom','age':18}
func(name='tom',age=18) # 传**li kargs = {'name':'tom', age:18, 'gender':'male'}
li = {'name':'tom', age:18, 'gender':'male'}
func(**li)
def func(*args, **kwargs):

    print args
print kwargs 注意:这两个形参不能调换顺序,就像默认参数必须放在形参列表最后一样。

内置函数

  • abs()

    取绝对值

abs(-10)

10

abs(10)

10

```
  • all()

    传一个可迭代的参数,如列表,只要列表中所有的值为真返回值才为真,有一个为假返回值就为假

all([0,True,[1,2],{'name':'tom'}])

False

all([1,True,'a',[1]])

True

```
  • any()

    和all()正好相反

any([0,False,[],{},'hello'])

True

any([0,False,[],{},''])

False

```
  • ascii()

    忘了

ascii('张')

"'\u5f20'"

```
  • bin()

    将10进制转换成2进制(数字前面0b代表2进制)

bin(2)

'0b10'

bin(10)

'0b1010'

```
  • oct()

    将10进制转换成8进制(数字前面0o代表8进制)

oct(8)

'0o10'

oct(2)

'0o2'

```
  • hex()

    将10进制转换成16进制(数字前0x代表16进制)

hex(15)

'0xf'

hex(10)

'0xa'

hex(9)

'0x9'

```
  • bool()

    返回True或False

bool(1)

True

bool(0)

False

bool([])

False

bool([1,2])

True

```
  • bytes()

    忘了

bytes('张',encoding='gbk')

b'\xd5\xc5'

bytes('张',encoding='utf-8')

b'\xe5\xbc\xa0'

```
  • callable()

    检查对象object是否可调用,像函数,类也可被调用,实例是不可被调用,除非类中声明了__call__方法

def func():

... pass

...

callable(func) #函数是可被调用的

True

callable(str) #类可被调用

True

s = 'abcd'

callable(s)

False

help

```
  • chr()

    返回整数i所对应的Unicode字符(python2.7是返回整数i所对应的ASCII字符)

chr(65)

'A'

```
  • ord()

    和chr()相反。

ord('A')

65

```
  • compile()

    将source编译为代码或者AST对象。代码对象能够通过exec语句来执行或者eval()进行求值。

s = "print('hello,world!')"

result = compile(s,'','exec')

exec(result)

hello,world!

```
  • complex()

    复数
```
  • dict()

    字典类

dic = dict() #创建一个空字典

dic

{}

```
  • dir()

    不带参数时,返回当前范围内的变量、方法和定义的类型列表;

    带参数时,返回参数的属性、方法列表。

    如果参数包含方法__dir__(),该方法将被调用。当参数为实例时。

    如果参数不包含__dir__(),该方法将最大限度地收集参数信息

dir()

['builtins', 'doc', 'loader', 'name', 'package', 'spec', 'dic']

s = 'hello'

dir(s)

['add', 'class', 'contains', 'delattr', 'dir', 'doc', 'eq', 'format', 'ge', 'getattribute', 'getitem', 'getnewargs', 'gt', 'hash', 'init', 'iter', 'le', 'len', 'lt', 'mod', 'mul', 'ne', 'new', 'reduce', 'reduce_ex', 'repr', 'rmod', 'rmul', 'setattr', 'sizeof', 'str', 'subclasshook', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

```
  • divmod()

    获取商和余数

divmod(100,2)

(50, 0)

divmod(100,3)

(33, 1)

divmod(120.0,7)

(17.0, 1.0)

divmod(129.5,7)

(18.0, 3.5)

```
  • enumerate()

    返回一个可枚举的对象,该对象的next()方法将返回一个tuple

li =['a','b','c','d','e']

s = enumerate(li)

print(list(s))

[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd'), (4, 'e')]

dic = dict()

for i,v in enumerate(li):

... dic[i] = v

...

dic

{0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e'}

```
  • eval()

    计算表达式的值

s = '8*8'

eval(s)

64

```
  • exec()

    执行python代码

s = "print('hello,world')"

exec(s)

hello,world

```
  • filter()

    过滤,筛选符合条件的值。

li = [10, 20, 30, 40, 50]

result = filter(lambda num: num > 20, li) #简单的函数可用lambda表达式代替

print(list(result))

```
  • float()

    将整数或数字字符串转换成浮点数

float(10)

10.0

num = '100'

float(num)

100.0

```
  • format()

    字符串格式化

s = "I'm {0},{1} years old!"

s.format('tom',18)

"I'm tom,18 years old!"

s = "I'm {name},{age} years old!"

s.format(name='tom',age=18)

"I'm tom,18 years old!"

```
  • globals()

    返回一个字典,字典包含范围内的所有全局变量

print(globals())

{'loader': <class '_frozen_importlib.BuiltinImporter'>, 'v': 'e', 'builtins': <module 'builtins' (built-in)>, 'spec': None, 'package': None, 's': "I'm {name},{age} years old!", 'dic': {0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e'}, 'li': ['a', 'b', 'c', 'd', 'e'], 'i': 4, 'name': 'main', 'doc': None, 'num': '100'}

```
  • hash()

    创建一个hash值

s = 'hello,world'

hash(s)

6931535528834423677

```
  • help()

    查看帮助信息

li = [1,2,4,3]

help(li.sort)

Help on built-in function sort

sort(...) method of builtins.list instance

L.sort(key=None, reverse=False) -> None -- stable sort IN PLACE

```
  • id()

    查看对象的内存地址

s = 'hello,world'

id(s)

139749839772464

```
  • input()

    等待用户输入

s = input('username:')

username:tom

print(s)

tom

```
  • int()

    转换成整型数

s = '10' #将字符串强转成数字

int(s)

10

f = 15.3 #将浮点数转换成整型数,会损失精度

int(f)

15

```
  • isinstance()

    判断对象是否是某个类的实例

s = 'hello,world'

isinstance(s,str) #判断s是否是str类的实例

True

isinstance(s,dict)

False

```
  • len()

    求对象的长度或元素的个数

s = 'hello,world'

len(s)

11

li = [1,2,3,4,5]

len(li)

5

t = (1,2,3,4,5)

len(t)

5

```
  • list()

    创建列表或转换成列表

li = list() #创建一个空列表

li

[]

```
  • locals()

    查看所有局部变量
```
  • map()

    此函数有两个参数,第一个是函数名,第二个是可迭代的对象。遍历每个元素,执行function操作

li = [10,20,30,40,50]

result = map(lambda num:num+100,li)

print(list(result))

[110, 120, 130, 140, 150]

```
  • max()

    求最大值,参数可以传一个可迭代的对象,如列表,返回最大的元素;如果是两个或两个以上的参数,返回最大的那一个

max(10,20,40,60) #传多个参数

60

li = [10,20,40,50] #传一个列表

max(li)

```
  • min()

    求最小值,参数和max()一样,返回最小的那个元素或值

li = [10,20,40,50]

min(li)

10

min(10,20,40,50)

10

```
  • open()

    文件操作,打开文件

f = open('test.txt','r') #以只读的方式打开test.txt文件

```
  • pow()

    求第一个参数的第二个参数次方

pow(2,10)

1024

```
  • print()

    格式化输出函数

print('hello,world')

hello,world

print("I'm %s,%d years old" %('tom',18))

I'm tom,18 years old

```
  • range()

    产生一个序列,默认从0开始

list(range(6))

[0, 1, 2, 3, 4, 5]

list(range(1,6))

[1, 2, 3, 4, 5]

list(range(0,6,2))

[0, 2, 4]

```
  • repr()

    返回一个字符串可打印对象

repr('hello')

"'hello'"

```
  • reversed()

    反转,和列表里的reversed基本一样,他会去调用列表里的resversed方法

li = [1,2,3,4,5]

reversed(li)

<list_reverseiterator object at 0x7f1a0b8988d0>

list(reversed(li))

[5, 4, 3, 2, 1]

```
  • round()

    四舍五入

round(5.6)

6

round(5.4)

5

```
  • set()

    创建一个空集合,或者转换成一个集合

s = set() #创建空集合

s

set()

s = set([1,2,4,4,5]) #传入一个可迭代的对象,将列表转换为集合

s

{1, 2, 4, 5}

```
  • slice()

    切片
```
  • sorted()

    排序,和list类里的sort方法相似

li = [1,5,3,4,2]

sorted(li)

[1, 2, 3, 4, 5]

li

[1, 5, 3, 4, 2]

sorted(li,reverse=True)

[5, 4, 3, 2, 1]

```
  • str()

    字符串类

str(231)

'231'

```
  • sum()

    求和

sum([1,2,3,4,5]) #参数为可迭代的对象

15

```
  • tuple()

    返回一个不可变的元组

t = tuple() #创建一个空元组

t

()

t = tuple([1,2,3,4,5]) #传入一个列表,将列表转换成元组

t

(1, 2, 3, 4, 5)

```
  • type()

    查看对象数据类型

t

(1, 2, 3, 4, 5)

type(t)

<class 'tuple'>

type('hello')

<class 'str'>

type([1,2,3,4,5])

<class 'list'>

```
  • vars()

    返回对象的属性,当不加参数的时,等同locals(),当有一个参数时, 这个参数必须有__dict__属性

vars()

```
  • zip()

    解释起来好复杂,直接看例子吧

li1 = [1,2,3]

li2 = [4,5,6]

zip(li1,li2)

<zip object at 0x7f1a0b889048>

list(zip(li1,li2))

[(1, 4), (2, 5), (3, 6)]

```

未完待续。。。

局部变量和全局变量

  • 局部变量

    在函数字义内定义的变量为局部变量,只能在函数体内使用。
def func1():
name = 'tom'
age = 18
print('I am %s,%d years old!' % (name,age)) func1() print('I am %s,%d years old!' % (name,age)) #在函数体外无法找到这两个变量 执行结果:
I am tom,18 years old!
Traceback (most recent call last):
File "local.py", line 10, in <module>
print('I am %s,%d years old!' % (name,age))
NameError: name 'name' is not defined
  • 全局变量

    在文件头定义,并且在函数体外定义的为变量为全局变量,在python中全局变量虽然没有规定大不写,但是我们约定全局变量都大写。

    全局变量在函数内只能读取,不能修改,如果想要在函数内修改得在函数内加global关键字
NAME = 'jerry'
AGE = 20 def func1():
NAME = 'jack' #注意,这并不是修改的全局变量,这相当于字义了一个和全局变量名字相同的局部变量
AGE = 30
name = 'tom'
age = 18
print('I am %s,%d years old!' % (name,age))
print('I AM %s,%d YEARS OLD!' % (NAME,AGE)) func1()
print('I am %s,%d years old!' % (NAME,AGE)) 程序结果:
I am tom,18 years old!
I AM jack,30 YEARS OLD!
I am jerry,20 years old!

如果想在函数里修改全局变量,则需要global关键字

NAME = 'jerry'
AGE = 20 def func1():
global NAME
global AGE
NAME = 'jack' #注意,这并不是修改的全局变量,这相当于字义了一个和全局变量名字相同的局部变量
AGE = 30
name = 'tom'
age = 18
print('I am %s,%d years old!' % (name,age))
print('I AM %s,%d YEARS OLD!' % (NAME,AGE)) func1()
print('I am %s,%d years old!' % (NAME,AGE)) 程序结果:
I am tom,18 years old!
I AM jack,30 YEARS OLD!
I am jack,30 years old!

文件操作

文件操作的三个步骤:

  • 打开文件
  • 操作文件
  • 关闭文件

操作文件的函数:

文件句柄 = open('文件路径', '模式')

打开文件

打开文件时,需要指定文件路径和以何等方式打开文件,打开后,即可获取该文件句柄,日后通过此文件句柄对该文件操作。

打开文件的方式有:

  • r,只读模式,如果open打开文件不指定打开模式,默认为只读模式
  • w,只写模式,如果文件不存在则创建,存在则清空文件内容
  • x, 只写模式,不可读;不存在则创建,存在则报错。python3中才有的,python2中没有这个方式。
  • a, 追加模式 可读,不存在则创建;存在则只追加内容;

"+" 表示可以同时读写某个文件

  • r+, 读写,可读,可写(最常用)
  • w+,写读,可读,可写
  • x+ ,写读,可读,可写
  • a+, 写读,可读,可写

"b"表示以字节的方式操作

  • rb 或 r+b
  • wb 或 w+b
  • xb 或 w+b
  • ab 或 a+b

注:以b方式打开时,读取到的内容是字节类型,写入时也需要提供字节类型

操作文件

操作文件的方法:

  • 关闭文件

    def close(self, *args, **kwargs):

f = open('test.txt','w')

f.close()

```
  • 打开文件描述符

    def fileno(self, *args, **kwargs):

f = open('test.txt','r')

f.fileno()

3

```
  • 刷新文件内部缓存区

    def flush(self, *args, **kwargs):

f = open('test.txt','w')

f.write('hello,world!') #这时内容还在缓存区里保存着,并没有写到磁盘上

f.flush() #强刷缓存区的内容到磁盘

```
  • 判断文件是否是tty设备(linux系统)

    def isatty(self, *args, **kwargs):

f = open('test.txt','w')

f.isatty()

False

```
  • 读取指定字节数据

    def read(self, *args, **kwargs):

f = open('test.txt','r')

f.read(10)

'hello,worl'

```
  • 是否可读

    def readable(self, *args, **kwargs):

f = open('test.txt','w')

f.readable()

False

```
  • 仅读取一行数据

    def readline(self, *args, **kwargs):

f = open('test.txt','r')

f.readline()

'hello,world!\n'

f.readline()

'hello,python!'

```
  • 指定文件中的指针位置

    def seek(self, *args, **kwargs):

f = open('test.txt','r')

f.seek(10) #移动到第10个字符

10

f.read(5) #从第10个字符开始读5个字符

'd!\nhe'

```
  • 指针是否可操作

    def seekable(self, *args, **kwargs):

f = open('test.txt','a')

f.seekable()

True

```
  • 获取指针位置

    def tell(self, *args, **kwargs):

f.close()

f = open('test.txt','r')

f.tell()

0

```
  • 写内容

    def write(self, *args, **kwargs):

f = open('test.txt','w')

f.write('hello,word!')

11

f.close()

```
  • 是否可写

    def writable(self, *args, **kwargs):

f = open('test.txt','r')

f.writable()

False

f.close()

f = open('test.txt','w')

f.writable()

True

f.close()

```

管理上下文

为了避免打开文件后忘记关闭,可以通过管理上下文,即:

with open('log','r') as f:
...

如此方式,当with代码块执行完毕时,内部会自动关闭并释放文件资源。

在Python 2.7 及以后,with又支持同时对多个文件的上下文进行管理,即:

with open('text.txt') as f1, open('text2.txt') as f2:

    pass

三元运算

学习条件运算时,对于简单的 if else 语句,可以使用三元运算来表示,即:

# 普通条件语句
if 1 == 1:
name = 'tom'
else:
name = 'jerry'
# 三元运算
name = 'tom' if 1 == 1 else 'jerry'

lambda表达式

对于简单的函数,也存在一种简便的表示方式,即:lambda表达式

# 定义函数(普通方式)

def func(arg):
return arg + 1 # 执行函数
result = func(123) # 定义函数(lambda表达式) my_lambda = lambda arg : arg + 1 # 执行函数 result = my_lambda(123)

Python之路第三天,基础(3)-set,函数,内置函数,文件,三元运算,lambda的更多相关文章

  1. python面向对象的基础语法(dir内置函数、self参数、初始化方法、内置方法和属性)

    面相对象基础语法 目标 dir 内置函数 定义简单的类(只包含方法) 方法中的 self 参数 初始化方法 内置方法和属性 01. dir 内置函数(知道) 在 Python 中 对象几乎是无所不在的 ...

  2. Python第七天 函数 函数参数 函数里的变量 函数返回值 多类型传值 函数递归调用 匿名函数 内置函数

    Python第七天   函数  函数参数   函数里的变量   函数返回值  多类型传值     函数递归调用   匿名函数   内置函数 目录 Pycharm使用技巧(转载) Python第一天   ...

  3. python 函数--内置函数

    一.内置函数 内置函数是python自带的一系列常用函数. 二.python3中内置函数     内置功能     abs() delattr() hash() memoryview() set() ...

  4. python 匿名函数&内置函数

    匿名函数:为了解决那些功能很简单的需求而设计的一句话函数怎么定义匿名函数: cal = lambda x : x*x # cal是函数名,lambda是定义匿名函数的关键字 冒号前面的额x是参数即函数 ...

  5. Python学习笔记014——迭代工具函数 内置函数enumerate()

    1 描述 enumerate() 函数用于将一个可遍历的数据对象(如列表.元组或字符串)组合为一个索引序列,同时列出数据和数据下标,一般用在 for 循环当中. 2 语法 enumerate(sequ ...

  6. python基础12_匿名_内置函数

    一个二分查找的示例: # 二分查找 示例 data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35, 36, ...

  7. Python基础(七)内置函数

    今天来介绍一下Python解释器包含的一系列的内置函数,下面表格按字母顺序列出了内置函数: 下面就一一介绍一下内置函数的用法: 1.abs() 返回一个数值的绝对值,可以是整数或浮点数等. 1 2 3 ...

  8. Python成长之路第二篇(1)_数据类型内置函数用法

    数据类型内置函数用法int 关于内置方法是非常的多这里呢做了一下总结 (1)__abs__(...)返回x的绝对值 #返回x的绝对值!!!都是双下划线 x.__abs__() <==> a ...

  9. python基础之 装饰器,内置函数

    1.闭包回顾 在学习装饰器之前,可以先复习一下什么是闭包? 在嵌套函数内部的函数可以使用外部变量(非全局变量)叫做闭包! def wrapper(): money =10 def inner(num) ...

  10. python基础(10)-匿名函数&内置函数

    匿名函数 例子 返回两个数的和 def add(x, y): return x + y # 等价于 add = lambda x, y: x + y 返回字典中值最大的key dic = {'a': ...

随机推荐

  1. java static关键字

    方便在没有创建对象的情况下来进行调用(方法/变量). 很显然,被static关键字修饰的方法或者变量不需要依赖于对象来进行访问,只要类被加载了,就可以通过类名去进行访问. static可以用来修饰类的 ...

  2. 2Sum,3Sum,4Sum,kSum,3Sum Closest系列

    1).2sum 1.题意:找出数组中和为target的所有数对 2.思路:排序数组,然后用两个指针i.j,一前一后,计算两个指针所指内容的和与target的关系,如果小于target,i右移,如果大于 ...

  3. 字符和字符串处理-ANSI字符和Unicode字符

    我们知道,C语言用char数据类型表示一个8位的ANSI字符,默认在代码中声明一个字符串时,C编译器会把字符串中的字符转换成由8位char数据类型构成的一个数组: // An 8-bit charac ...

  4. HTML5动画图片播放器 高端大气

    我们见过很多图片播放插件(焦点图),很多都基于jQuery.今天介绍的HTML5图片播放器很特别,它不仅在图片间切换有过渡动画效果,而且在切换时图片中的元素也将出现动画效果,比如图中的文字移动.打散. ...

  5. 正式学习 react(三)

    有了基础的webpack基础,我们要对react的基本语法进行学习. 我这个教程全部用es6 实现.可能会忽略一些最基本的语法讲解,这些你在官网上或者其他别的地方都比我讲的全. 今天我要讲一下reac ...

  6. WSImport

    http://www.cnblogs.com/simle/archive/2011/11/03/2233417.html

  7. C++STL_sort

    #include<algorithm> #include<iostream> using namespace std; void print(int x) { cout< ...

  8. 顶尖数据挖掘开发平台(TipDM-D2)产品白皮书

          顶尖数据挖掘开发平台 (TipDM-D2)           产  品  白  皮  书 广州泰迪智能科技有限公司 版权所有 地址: 广州市经济技术开发区科学城232号 网址: http ...

  9. Centos 6.8下安装LBP2900打印机驱动

    今天第一次在Linux下面安装LBP2900的驱动程序,在安装的过程中出现了不少的问题,不过问题最终还是解决了. 1.下载LBP2900的Linux驱动程序: Linux_LBP2900_CAPT_P ...

  10. cocos2d-x 学习笔记一(概述)

    1.游戏-可控制的动画-连续的静态图像 2.关键帧驱动游戏 3.事件驱动型游戏 4.cocos2d-x 1.0 opengl-es 1.0;cocos2d-x 2.x opengl-es 2.0;co ...