简明Python教程学习笔记_4_数据结构

在Python中有三种内建的数据结构——列表、元组和字典。

列表

list是处理一组有序项目的数据结构,即你可以在一个列表中存储一个 序列 的项目。假想你有一个购物列表,上面记载着你要买的东西,你就容易理解列表了。只不过在你的购物表上,可能每样东西都独自占有一行,而在Python中,你在每个项目之间用逗号分割。

列表中的项目应该包括在方括号中,这样Python就知道你是在指明一个列表。一旦你创建了一个列表,你可以添加、删除或是搜索列表中的项目。由于你可以增加或删除项目,我们说列表是可变的 数据类型,即这种类型是可以被改变的。

>>>mylist=[1,2,3,a,b,c]
>>>type(mylist)
>>><type  'list'>
>>>dir(list)
>>>dir(mylist)
>>>help(list)

对象与类的快速入门

尽管我一直推迟讨论对象和类,但是现在对它们做一点解释可以使你更好的理解列表。我们会在相应的章节详细探索这个主题。

列表是使用对象和类的一个例子。当你使用变量i并给它赋值的时候,比如赋整数5,你可以认为你创建了一个(类型)int对象(实例)i。事实上,你可以看一下help(int)以更好地理解这一点。

类也有方法,即仅仅为类而定义地函数。仅仅在你有一个该类的对象的时候,你才可以使用这些功能。例如,Python为list类提供了append方法,这个方法让你在列表尾添加一个项目。例如mylist.append('an item')列表mylist中增加那个字符串。注意,使用点号来使用对象的方法。

一个类也有,它是仅仅为类而定义的变量。仅仅在你有一个该类的对象的时候,你才可以使用这些变量/名称。类也通过点号使用,例如mylist.field

使用列表

#!/usr/bin/python
# Filename: using_list.py# This is my shopping list
shoplist = ['apple', 'mango','carrot','banana']print 'I have', len(shoplist),'items to purchase.'
print 'These items are:',# Notice the comma at end of the line
for item in shoplist:print item,
print '\nI also have to buy rice.'
shoplist.append('rice')
print 'My shopping list is now', shoplistprint 'I will sort my list now'
shoplist.sort()
print 'Sorted shopping list is', shoplistprint 'The first item I will buy is', shoplist[0]
olditem = shoplist[0]
del shoplist[0]
print 'I bought the', olditem
print 'My shopping list is now', shoplist 输出
$ python using_list.py
I have 4 items to purchase.
These items are: apple mango carrot banana
I also have to buy rice.
My shopping list is now ['apple', 'mango', 'carrot', 'banana', 'rice']
I will sort my list now
Sorted shopping list is ['apple', 'banana', 'carrot', 'mango', 'rice']
The first item I will buy is apple
I bought the apple
My shopping list is now ['banana', 'carrot', 'mango', 'rice'] 

它如何工作

变量shoplist是某人的购物列表。在shoplist中,我们只存储购买的东西的名字字符串,但是记住,你可以在列表中添加任何种类的对象 包括数甚至其他列表。

我们也使用了for..in循环在列表中各项目间递归。从现在开始,你一定已经意识到列表也是一个序列。序列的特性会在后面的章节中讨论。

注意,我们在print语句的结尾使用了一个 逗号 来消除每个print语句自动打印的换行符。这样做有点难看,不过确实简单有效。

接下来,我们使用append方法在列表中添加了一个项目,就如前面已经讨论过的一样。然后我们通过打印列表的内容来检验这个项目是否确实被添加进列表了。打印列表只需简单地把列表传递给print语句,我们可以得到一个整洁的输出。

再接下来,我们使用列表的sort方法来对列表排序。需要理解的是,这个方法影响列表本身,而不是返回一个修改后的列表——这与字符串工作的方法不同。这就是我们所说的列表是可变的 而字符串是不可变的

最后,但我们完成了在市场购买一样东西的时候,我们想要把它从列表中删除。我们使用del语句来完成这个工作。这里,我们指出我们想要删除列表中的哪个项目,而del语句为我们从列表中删除它。我们指明我们想要删除列表中的第一个元素,因此我们使用del shoplist[0](记住,Python从0开始计数)。

如果你想要知道列表对象定义的所有方法,可以通过help(list)获得完整的知识。

列表综合

通过列表综合,可以从一个已有的列表导出一个新的列表。例如,你有一个数的列表,而你想要得到一个对应的列表,使其中所有大于2的数都是原来的2倍。对于这种应用,列表综合是最理想的方法。

dfadsf

使用列表综合

#!/usr/bin/python
# Filename: list_comprehension.pylistone = [2, 3,4]
listtwo = [2*i for i in listone if i>2]
print listtwo
输出
$ python list_comprehension.py
[6, 8]

它如何工作

这里我们为满足条件(if i > 2)的数指定了一个操作(2*i),从而导出一个新的列表。注意原来的列表并没有发生变化。在很多时候,我们都是使用循环来处理列表中的每一个元素,而使用列表综合可以用一种更加精确、简洁、清楚的方法完成相同的工作。

元组

元组和列表十分类似,只不过元组和字符串一样是  不可变的 即你不能修改元组。元组通过圆括号中用逗号分割的项目定义。元组通常用在使语句或用户定义的函数能够安全地采用一组值的时候,即被使用的元组的值不会改变。

使用元组

#!/usr/bin/python
# Filename: using_tuple.pyzoo = ('wolf', 'elephant','penguin')
print 'Number of animals in the zoo is',len(zoo)new_zoo = ('monkey', 'dolphin', zoo)
print 'Number of animals in the new zoo is',len(new_zoo)
print 'All animals in new zoo are', new_zoo
print 'Animals brought from old zoo are', new_zoo[2]
print 'Last animal brought from old zoo is', new_zoo[2][2]输出
$ python using_tuple.py
Number of animals in the zoo is 3
Number of animals in the new zoo is 3
All animals in new zoo are ('monkey', 'dolphin', ('wolf', 'elephant', 'penguin'))
Animals brought from old zoo are ('wolf', 'elephant', 'penguin')
Last animal brought from old zoo is penguin 

它如何工作

变量zoo是一个元组,我们看到len函数可以用来获取元组的长度。这也表明元组也是一个序列。
由于老动物园关闭了,我们把动物转移到新动物园。因此,new_zoo元组包含了一些已经在那里的动物和从老动物园带过来的动物。回到话题,注意元组之内的元组不会失去它的身份。
我们可以通过一对方括号来指明某个项目的位置从而来访问元组中的项目,就像我们对列表的用法一样。这被称作 索引 运算符。我们使用new_zoo[2]来访问new_zoo中的第三个项目。我们使用new_zoo[2][2]来访问new_zoo元组的第三个项目的第三个项目。

含有0个或1个项目的元组。

一个空的元组由一对空的圆括号组成,如myempty = ()。然而,含有单个元素的元组就不那么简单了。你必须在第一个(唯一一个)项目后跟一个逗号,这样Python才能区分元组和表达式中一个带圆括号的对象。即如果你想要的是一个包含项目2的元组的时候,你应该指明singleton = (2 , )。
给Perl程序员的注释
列表之中的列表不会失去它的身份,即列表不会像Perl中那样被打散。同样元组中的元组,或列表中的元组,或元组中的列表等等都是如此。只要是Python,它们就只是使用另一个对象存储的对象。


元组与打印语句

元组最通常的用法是用在打印语句中,下面是一个例子:

#!/usr/bin/python
# Filename: print_tuple.pyage = 22
name = 'Swaroop'print '%s is %d years old' % (name, age)
print 'Why is %s playing with that python?'% name
输出
$ python print_tuple.py
Swaroop is 22 years old
Why is Swaroop playing with that python?dictName={'name':'xiaoming','name1':'xiaofang','name2':'huangdi'}
print 'dictName[name] ',dictName['name']
print '\n'
print 'dictName[name]  %s'%dictName['name']
print '\n'
print 'dictName[name1]  ,dictName[name2] ',dictName['name1'],dictName['name2']
print '\n'
print 'dictName[name1] %s ,dictName[name2] %s'%(dictName['name1'],dictName['name2'])

它如何工作

print语句可以使用跟着%符号的项目元组的字符串。这些字符串具备定制的功能。定制让输出满足某种特定的格式。定制可以是%s表示字符串或%d表示整数。元组必须按照相同的顺序来对应这些定制。

观察我们使用的第一个元组,我们首先使用%s,这对应变量name,它是元组中的第一个项目。而第二个定制是%d,它对应元组的第二个项目age

Python在这里所做的是把元组中的每个项目转换成字符串并且用字符串的值替换定制的位置。因此%s被替换为变量name的值,依此类推。

print的这个用法使得编写输出变得极其简单,它避免了许多字符串操作。它也避免了我们一直以来使用的逗号。

在大多数时候,你可以只使用%s定制,而让Python来提你处理剩余的事情。这种方法对数同样奏效。然而,你可能希望使用正确的定制,从而可以避免多一层的检验程序是否正确。

在第二个print语句中,我们使用了一个定制,后面跟着%符号后的单个项目——没有圆括号。这只在字符串中只有一个定制的时候有效。


交换变量值

一般的交换两个变量的值是用过一个临时变量、或者 异或、或者相加、或者相乘。但是 Python中有一种赋值机制即多元赋值,采用这种方式赋值时,等号两边的对象都是元组并且元组的小括号是可选的。通常形式为

x, y, z = 1, 2, 'a string'

等同于 (x, y, z) = (1, 2, 'a string') 。这种赋值类型最经常用到的环境是变量交换,形如:  x, y = y, x

这种交换方式无需中间变量即可交换两个变量的值。那么具体实现机制是怎样的呢?

运行时,首先构造一个元组(y, x),然后构造另一个元组(x, y),接着用元组(y, x)赋值给(x, y),元组赋值过程从左到右,依次进行。假如x=1,y=2,先令x=y,此时x=2,然后令y=x,y应该等于2?那么就不能实现变量交换了?对于这个问题,应该从元组的特性说起。

x, y, z = 1, 2, 'a string'
tuple = (x, y, z)

变量名x, y, z都是引用,内存开辟除了三个空间分别存储1, 2, 'a string',三个变量分别指向这三块地址。由这三个变量构造的元组tuple,它有三个元素,这三个元素并不是x,y,z这三个变量,而是这三个变量所指向的地址空间里的内容。如果此时再另x=4,此时在地址空间会另开辟出一块空间存储4,x进而指向这块空间,而元组内的三个值仍保持不变。

所以对于 x, y = y, x 来说,首先由y,x所构成的元组(y,x)其实应该表示为(2,1),那么再从左到右赋值,就可以交换变量的值了。


在函数中接收元组和列表

使函数接收元组或字典形式的参数的时候,可以分别使用  和  ** 前缀。这种方法在函数需要获取可变数量的参数的时候特别有用。

>>> def powersum(power, *args):
... '''Return the sum of each argument raised to specified power.'''
... total = 0
... for i in args:
... total += pow(i, power)
... return total
...
>>> powersum(2, 3, 4)
25>>> powersum(2, 10)
100

由于在args变量前有*前缀,所有多余的函数参数都会作为一个元组存储在args中。如果使用的是**前缀,多余的参数则会被认为是一个字典的键/值对。

字典

字典类似于你通过联系人名字查找地址和联系人详细情况的地址簿,即,我们把(名字)和(详细情况)联系在一起。注意,键必须是唯一的,就像如果有两个人恰巧同名的话,你无法找到正确的信息。

注意,你只能使用不可变的对象(比如字符串)来作为字典的键,但是你可以使用不可变或可变的对象作为字典的值。基本说来就是,你应该只使用简单的对象作为键。

键值对在字典中以这样的方式标记:d = {key1 : value1, key2 : value2 }。注意它们的键/值对用冒号分割,而各个对用逗号分割,所有这些都包括在花括号中。

记住字典中的键/值对是没有顺序的。如果你想要一个特定的顺序,那么你应该在使用前自己对它们排序。

字典是dict类的实例/对象。

#!/usr/bin/python
# Filename: using_dict.py# 'ab' is short for 'a'ddress'b'ookab = {       'Swaroop'   : 'swaroopch@byteofpython.info','Larry'     : 'larry@wall.org','Matsumoto' : 'matz@ruby-lang.org','Spammer'   : 'spammer@hotmail.com'}print "Swaroop's address is %s" % ab['Swaroop']# Adding a key/value pair
ab['Guido'] = 'guido@python.org'# Deleting a key/value pair
del ab['Spammer']print '\nThere are %d contacts in the address-book\n'%len(ab)
for name, address in ab.items():print 'Contact %s at %s' % (name, address)if 'Guido' inab:# OR ab.has_key('Guido')print "\nGuido's address is %s" % ab['Guido']结果
$ python using_dict.py
Swaroop's address is swaroopch@byteofpython.infoThere are 4 contacts in the address-bookContact Swaroop at swaroopch@byteofpython.info
Contact Matsumoto at matz@ruby-lang.org
Contact Larry at larry@wall.org
Contact Guido at guido@python.orgGuido's address is guido@python.org 

它如何工作

我们使用已经介绍过的标记创建了字典ab。然后我们使用在列表和元组章节中已经讨论过的索引操作符来指定键,从而使用键/值对。我们可以看到字典的语法同样十分简单。

我们可以使用索引操作符来寻址一个键并为它赋值,这样就增加了一个新的键/值对,就像在上面的例子中我们对Guido所做的一样。

我们可以使用我们的老朋友——del语句来删除键/值对。我们只需要指明字典和用索引操作符指明要删除的键,然后把它们传递给del语句就可以了。执行这个操作的时候,我们无需知道那个键所对应的值。

接下来,我们使用字典的items方法,来使用字典中的每个键/值对。这会返回一个元组的列表,其中每个元组都包含一对项目——键与对应的值。我们抓取这个对,然后分别赋给for..in循环中的变量nameaddress然后在for-块中打印这些值。

我们可以使用in操作符来检验一个键/值对是否存在,或者使用dict类的has_key方法。你可以使用help(dict)来查看dict类的完整方法列表。

关键字参数与字典。如果换一个角度看待你在函数中使用的关键字参数的话,你已经使用了字典了!只需想一下——你在函数定义的参数列表中使用的键/值对。当你在函数中使用变量的时候,它只不过是使用一个字典的键(这在编译器设计的术语中被称作符号表 )。

序列

列表、元组和字符串都是序列,但是序列是什么,它们为什么如此特别呢?序列的两个主要特点是索引操作符和切片操作符。索引操作符让我们可以从序列中抓取一个特定项目。切片操作符让我们能够获取序列的一个切片,即一部分序列。


切片操作:[开始位置:结束位置:步长]

tempList=[0,1,2,3,4,5]
print tempList[::4]#结果 [0, 4]  从 开始位置 到 结束位置 且步长为4的位置的值 组成一个新的List ,并打印
temp = [x for x in range(11)]
print tem0[::2]
print temp[::]
print temp[1:-1]


使用序列
#!/usr/bin/python
# Filename: seq.pyshoplist = ['apple', 'mango','carrot','banana']# Indexing or 'Subscription' operation
print 'Item 0 is', shoplist[0]
print 'Item 1 is', shoplist[1]
print 'Item 2 is', shoplist[2]
print 'Item 3 is', shoplist[3]
print 'Item -1 is', shoplist[-1]
print 'Item -2 is', shoplist[-2]# Slicing on a list
print 'Item 1 to 3 is', shoplist[1:3]
print 'Item 2 to end is', shoplist[2:]
print 'Item 1 to -1 is', shoplist[1:-1]
print 'Item start to end is', shoplist[:]# Slicing on a string
name = 'swaroop'
print 'characters 1 to 3 is', name[1:3]
print 'characters 2 to end is', name[2:]
print 'characters 1 to -1 is', name[1:-1]
print 'characters start to end is', name[:]输出
$ python seq.py
Item 0 is apple
Item 1 is mango
Item 2 is carrot
Item 3 is banana
Item -1 is banana
Item -2 is carrot
Item 1 to 3 is ['mango', 'carrot']
Item 2 to end is ['carrot', 'banana']
Item 1 to -1 is ['mango', 'carrot']
Item start to end is ['apple', 'mango', 'carrot', 'banana']
characters 1 to 3 is wa
characters 2 to end is aroop
characters 1 to -1 is waroo
characters start to end is swaroop 

它如何工作

首先,我们来学习如何使用索引来取得序列中的单个项目。这也被称作是下标操作。每当你用方括号中的一个数来指定一个序列的时候,Python会为你抓取序列中对应位置的项目。记住,Python从0开始计数。因此,shoplist[0]抓取第一个项目,shoplist[3]抓取shoplist序列中的第四个元素。

索引同样可以是负数,在那样的情况下,位置是从序列尾开始计算的。因此,shoplist[-1]表示序列的最后一个元素而shoplist[-2]抓取序列的倒数第二个项目。

切片操作符是序列名后跟一个方括号,方括号中有一对可选的数字,并用冒号分割。注意这与你使用的索引操作符十分相似。记住数是可选的,而冒号是必须的。

切片操作符中的第一个数(冒号之前)表示切片开始的位置,第二个数(冒号之后)表示切片到哪里结束。如果不指定第一个数,Python就从序列首开始。如果没有指定第二个数,则Python会停止在序列尾。注意,返回的序列从开始位置开始 ,刚好在结束 位置之前结束。即开始位置是包含在序列切片中的,而结束位置被排斥在切片外。

这样,shoplist[1:3]返回从位置1开始,包括位置2,但是停止在位置3的一个序列切片,因此返回一个含有两个项目的切片。类似地,shoplist[:]返回整个序列的拷贝。

你可以用负数做切片。负数用在从序列尾开始计算的位置。例如,shoplist[:-1]会返回除了最后一个项目外包含所有项目的序列切片。

使用Python解释器交互地尝试不同切片指定组合,即在提示符下你能够马上看到结果。序列的神奇之处在于你可以用相同的方法访问元组、列表和字符串。

参考

当你创建一个对象并给它赋一个变量的时候,这个变量仅仅 参考 那个对象,而不是表示这个对象本身!也就是说,变量名指向你计算机中存储那个对象的内存。这被称作名称到对象的绑定

一般说来,你不需要担心这个,只是在参考上有些细微的效果需要你注意。这会通过下面这个例子加以说明。

对象与参考

#!/usr/bin/python
# Filename: reference.pyprint 'Simple Assignment'
shoplist = ['apple', 'mango','carrot','banana']
mylist = shoplist            # mylist is just another name pointing to the same object!del shoplist[0]print 'shoplist is', shoplist
print 'mylist is', mylist# notice that both shoplist and mylist both print the same list without# the 'apple' confirming that they point to the same objectprint 'Copy by making a full slice'
mylist = shoplist[:]                 # make a copy by doing a full slice
del mylist[0]# remove first itemprint 'shoplist is', shoplist
print 'mylist is', mylist# notice that now the two lists are different
输出$ python reference.py
Simple Assignment
shoplist is ['mango', 'carrot', 'banana']
mylist is ['mango', 'carrot', 'banana']
Copy by making a full slice
shoplist is ['mango', 'carrot', 'banana']
mylist is ['carrot', 'banana'] 

它如何工作

大多数解释已经在程序的注释中了。你需要记住的只是如果你想要复制一个列表或者类似的序列或者其他复杂的对象(不是如整数那样的简单 对象 ),那么你必须使用切片操作符来取得拷贝。如果你只是想要使用另一个变量名,两个名称都参考 同一个对象,那么如果你不小心的话,可能会引来各种麻烦。

给Perl程序员的注释
记住列表的赋值语句不创建拷贝。你得使用切片操作符来建立序列的拷贝。  

更多字符串的内容

我们已经在前面详细讨论了字符串。我们还需要知道什么呢?那么,你是否知道字符串也是对象,同样具有方法。这些方法可以完成包括检验一部分字符串和去除空格在内的各种工作。

你在程序中使用的字符串都是str类的对象。这个类的一些有用的方法会在下面这个例子中说明。如果要了解这些方法的完整列表,请参见help(str)

字符串的方法

#!/usr/bin/python
# Filename: str_methods.pyname = 'Swaroop' # This is a string objectif name.startswith('Swa'):print 'Yes, the string starts with "Swa"'if 'a' in name:print 'Yes, it contains the string "a"'if name.find('war') !=-1:print 'Yes, it contains the string "war"'delimiter = '_*_'
mylist = ['Brazil', 'Russia','India','China']
print delimiter.join(mylist)
输出$ python str_methods.py
Yes, the string starts with "Swa"
Yes, it contains the string "a"
Yes, it contains the string "war"
Brazil_*_Russia_*_India_*_China

它如何工作

这里,我们看到使用了许多字符串方法。startwith方法是用来测试字符串是否以给定字符串开始。in操作符用来检验一个给定字符串是否为另一个字符串的一部分。

find方法用来找出给定字符串在另一个字符串中的位置,或者返回-1以表示找不到子字符串。str类也有以一个作为分隔符的字符串join序列的项目的整洁的方法,它返回一个生成的大字符串。




本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/497247.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

動態修改SiteMapPath路徑

http://www.purecs.net/Threads/t376.aspx在網頁上放置一個SiteMapPath可以提供使用者一個清楚的瀏覽路標指示&#xff0c;如果你的SiteMap是靜態不會變動的倒是很簡單&#xff0c;只要編寫好一個XML檔放上去&#xff0c;其它的事就可以不用管了&#xff0c;但是在動態網頁中Si…

C++学习之路 | PTA乙级—— 1007 素数对猜想 (20分)(精简)

1007 素数对猜想 (20分) 让我们定义d ​n ​​ 为&#xff1a;d ​n ​​ p ​n1 ​​ −p ​n ​​ &#xff0c;其中p ​i ​​ 是第i个素数。显然有d ​1 ​​ 1&#xff0c;且对于n>1有d ​n ​​ 是偶数。“素数对猜想”认为“存在无穷多对相邻且差为2的素数”。 现给…

python: SHA256算法的实现和消息的哈希散列值计算

目录1 SHA2562 实现原理2.1 消息预处理2.2 使用的常量和循环移位函数2.3 主循环3 结果4 对中文编码1 SHA256 SHA256是SHA-2下的一个子算法&#xff0c;与之类似的还有SHA224、SHA384、SHA512&#xff0c;算法原理基本一致。 哈希算法通过对消息进行计算&#xff0c;生成一定长…

财报上的云计算战场: 巨头们垄断加剧

来源&#xff1a; 第一财经一周之内&#xff0c;四大云业务巨头公司前后脚发布财报。亚马逊的云业务&#xff08;AWS&#xff09;依然跑在了最前面&#xff0c;以174亿美元排在首位。微软、谷歌、阿里巴巴也没有放慢步伐。阿里云去年累计的营收超过了百亿&#xff1b;微软的Azu…

Preserve Whole Object(保持对象完整)

从某个对象中取出若干值&#xff0c;将它们作为某一次函数调用的参数 int low daysTempRange().getLow(); int height daysTempRange().getHigh(); withinPlan plan.withinRange(low, high); 重构&#xff1a;改为传递整个对象 withinPlan plan.withinRange(daysTempRan…

简明Python教程学习笔记_5_解决问题

问题 我提出的问题是&#xff1a; 我想要一个可以为我的所有重要文件创建备份的程序。 尽管这是一个简单的问题&#xff0c;但是问题本身并没有给我们足够的信息来解决它。进一步的分析是必需的。例如&#xff0c;我们如何确定该备份哪些文件&#xff1f;备份保存在哪里&#…

【开始研究Community Server,转贴一点东西】Community Server资料收集

Community Server学习资料 uGoer 系列文章 Community Server专题一&#xff1a;概述Community ServerCommunity Server专题二&#xff1a;体系结构Community Server专题&#xff1a;附件(DOC&PPT)--2005年10月10日更新Community Server专题三&#xff1a;HttpModuleCommuni…

python实现RSA算法,对数据进行加密认证

RSA算法RSA一、数学原理二、实现代码1 生成素数2 生成秘钥3 对数据进行加密、解密总结RSA RSA是一种非对称加密体制&#xff0c;由公钥和私钥组成&#xff0c;数学原理是实数域的模余法。在使用私钥对数据进行加密后&#xff0c;可用公钥对数据进行解密。 在RSA算法中&#xf…

C++学习之路 | PTA乙级—— 1008 数组元素循环右移问题 (20分)(精简)

1008 数组元素循环右移问题 (20分) 一个数组A中存有N&#xff08;>0&#xff09;个整数&#xff0c;在不允许使用另外数组的前提下&#xff0c;将每个整数循环向右移M&#xff08;≥0&#xff09;个位置&#xff0c;即将A中的数据由&#xff08;A ​0 ​​ A ​1 ​​ ⋯A …

他研究了5000家AI公司,说人工智能应用该这么做!

来源&#xff1a;公众号InfoQ编辑&#xff1a;陈思 Eva&#xff1b;视频剪辑&#xff1a;汪春良 概要&#xff1a;本文作者 Henry Shi是美国人工智能的博士&#xff0c;连续创业者&#xff0c;专注于 AI 领域的早期投资&#xff08;AI List Capital管理合伙人&#xff09;。无…

Replace Parameter with Methods(以函数取代参数)

对象调用某个函数&#xff0c;并将其结果传递给另一个函数 int basePrice quantity * itemPrice; double discountLevel getDiscountLevel(); double finalPrice discountPrice(basePrice, discountLevel); 重构&#xff1a;让参数接受者移除该项参数&#xff0c;并直接调…

简明Python教程学习笔记_6_面向对象编程

面向对象编程&#xff1a;https://www.liaoxuefeng.com/wiki/897692888725344/923030496738368面向对象高级编程&#xff1a;https://www.liaoxuefeng.com/wiki/897692888725344/9230305380126401、类、对象 类 和 对象 是面向对象编程的两个主要方面。 类 是创建一个 新类型&a…

C++学习之路 | PTA乙级—— 1009 说反话 (20分)(精简)

1009 说反话 (20分) 给定一句英语&#xff0c;要求你编写程序&#xff0c;将句中所有单词的顺序颠倒输出。 输入格式&#xff1a; 测试输入包含一个测试用例&#xff0c;在一行内给出总长度不超过 80 的字符串。字符串由若干单词和若干空格组成&#xff0c;其中单词是由英文字…

哈希值+非对称加密+网络+数字签名,你真的知道怎么给游戏充钱吗

前文 使用socket实现局域网不同主机通信 SHA256算法的实现和消息的哈希散列值计算 python实现RSA算法&#xff0c;对数据进行加密认证 文章目录数字签名与认证攻击类型算法选择实现流程总结数字签名与认证 什么是数字签名&#xff1f; 签名我们大家都知道&#xff0c;A在纸上签…

2017 年脑机接口研发热点回眸

来源&#xff1a;科技导报概要&#xff1a;脑机接口&#xff08;brain-computer interface&#xff0c;BCI&#xff09;通过解码人类思维活动过程中的脑神经活动信息&#xff0c;构建大脑与外部世界的直接信息传输通路&#xff0c;在神经假体、神经反馈训练、脑状态监测等领域有…

Visual Studio“Orcas”October 2006 CTP版下载

Visual Studio “Orcas” October 2006 CT版可以下载了&#xff0c;但这次Release的是一个虚拟机的镜像&#xff0c;所以需要在虚拟PC上运行&#xff0c;文件的大小是4150.5 MB&#xff0c;有点太大了。下载地址&#xff1a;http://www.microsoft.com/downloads/details.aspx?…

C++学习之路 | PTA乙级—— 1010 一元多项式求导 (25分)(精简)

1010 一元多项式求导 (25分) 设计函数求一元多项式的导数。&#xff08;注&#xff1a;x ​n ​​ &#xff08;n为整数&#xff09;的一阶导数为nx ​n−1 ​​ 。&#xff09; 输入格式: 以指数递降方式输入多项式非零项系数和指数&#xff08;绝对值均为不超过 1000 的整数…

简明 Python 教程学习笔记_7_文件操作(os、shutil、pathlib )

参考 &#xff1a;http://www.cnblogs.com/nulige/archive/2016/12/06/6037752.html 在很多时候&#xff0c;你会想要让你的程序与用户&#xff08;可能是你自己&#xff09;交互。你会从用户那里得到输入&#xff0c;然后打印一些结果。我们可以分别使用 raw_input 和 print 语…

地牢房间迷宫走廊生成(二),Python实现洪水法、完美迷宫

文章目录前言1 随机房间和房门2 生成走廊2.1生成迷宫2.4 使用循环改进2.3 走廊缩减2.3 走廊再简化总结前言 前面通过随机房间、房门&#xff0c;对房门寻路生成走廊。由于使用A星算法&#xff0c;寻到的是最短路径&#xff0c;这样生成的走廊过直和简单。如果需要生成弯曲的走廊…

Introduce Parameter Object(引入参数对象)

某些参数总是很自然地同时出现 重构&#xff1a;以一个对象取代这些参数