Swift教程之集合类型详解

Swift 提供两种集合类型来存储集合,数组和字典。数组是一个同类型的序列化列表集合。字典是一个能够使用类似于键的唯一标识符来获取值的非序列化集合。

在Swift中,数组和字典的键和值都必须明确它的类型。这意味这数组和字典不会插入一个错误的类型的值,以致于出错。这也意味着当你在数组和字典中取回数值的时候能够确定它的类型。
Swift 使用确定的集合类型可以保证代码工作是不会出错,和让你在开发阶段就能更早的捕获错误。
note:
Swift的数组 储存不同的类型会展示出不同的行为,例如变量,常量或者 函数和方法。更多的信息参见Mutability of Collections and Assignment 和 Copy Behavior for Collection Types.

1、数组

数组是储存同类型不同值的序列化列表。同样的值可以在数组的不同位置出现多次。

Swift数组是储存确定的值,这个Objective-C中的NSArray和NSMutableArray类是有区别的。因为它们是储存各种的对象,而且并不提供返回任何有关对象的具体信息。在Swift中,无论是确定的声明,还是隐式的声明,数组是非常确定它自身是储存什么样的类型,而且,它并不一定要求储存的是类对象。所以Swift数组是类型安全的,因为它一直都确定它自身所能包含的值。

数组的简略语法

定义数组的完整写法是Array<SomeType>。其中SomeType是你想要包含的类型。你也可以使用类似于SomeType[]这样的简略语法。虽然这两种方法在功能上是相同的。但是我们更推荐后者,而且它会一直贯穿于本书。

数组实量(Array Literals)

你可以用一个数组实量(Array Literals)来初始化一个数组,它是用简略写法来创建一个包含一个或多个的值的数组。一个数组实量(Array Literals)是由它包含的值,“,”分隔符 已经包括以上内容的中括号对“[]”组成:

代码如下:

[value 1, value 2, value 3]

下面的例子创建一个叫shoppinglist,储存字符串(String)类型的数组。

代码如下:

var shoppingList: String[] = ["Eggs", "Milk"]
// 使用两个初始化参数来初始化shoppingList

shoppinglist变量被定义为字符串(String)类型的数组,写作String[]。因为这个数组被确定为字符串类型(String),所以它只能储存字符串(String)类型的值。在这里,用两个字符串类型的值(”Eggs” and “Milk”)和数组实量(Array Literals)的写法来初始化shoppingList数组。

注意

shoppingList数组是被定义为一个变量(使用var 标识符)而不是常量(使用let 标识符),所以在下面的例子可以直接添加元素。

在这个例子中,数组实量(Array Literals)只包含两个字符串类型的值,这符合了shoppingList变量的定义(只能包含字符串(String)类型的数组),所以被分配的数组实量(Array Literals)被允许用两个字符串类型的值来初始化。

得益于Swift的类型推断,当你用相同类型的值来初始化时,你可以不写明类型。初始化shoppingList可以用下面这个方法来代替。

代码如下:

var shoppingList = ["Eggs", “Milk"]

因为数组实量(Array Literals)中所有的值都是同类型的,所以Swift能够推断shoppingList的类型为字符串数组(String[])。

读取和修改数组

你可以通过方法和属性,或者下标来读取和修改数组。

通过只读属性count来读取数组的长度;

代码如下:

println("The shopping list contains \(shoppingList.count) items.")
// prints "The shopping list contains 2 items.”

通过一个返回布尔类型的isEmpty属性检查数组的长度是否为0

代码如下:

if shoppingList.isEmpty {     println("The shopping list is empty.")
} else {     println("The shopping list is not empty.")
}
// prints "The shopping list is not empty."

在数组末尾增加一个元素可以通过append方法

代码如下:

shoppingList.append("Flour")
// shoppingList 现在包含3个元素

甚至,还可以用(+=)操作符来把一个元素添加到数组末尾

代码如下:

shoppingList += "Baking Powder"
// shoppingList 现在包含4个元素

你也可以用(+=)操作符来把一个数组添加到另一个数组的末尾

代码如下:

shoppingList += ["Chocolate Spread", "Cheese", "Butter"]
// shoppingList 现在包含7个元素

从数组中取出一个值可以使用下标语法。如果你知道一个元素的索引值,你可以数组名后面的中括号中填写索引值来获取这个元素

代码如下:

var firstItem = shoppingList[0]
// firstItem 等于 “Eggs"

注意,数组的第一个元素的索引值为0,不为1,Swift的数组总是索引0;

你可以使用下标语法通过索引修改已经存在的值。

代码如下:

shoppingList[0] = "Six eggs"
//列表中的第一个值等于"Six eggs" 而不等于 “Eggs"

你可以使用下标语法一次性改变一系列的值,尽管修改的区域远远大于要修改的值。在下面的雷子中, 替换掉 “Chocolate Spread”, “Cheese”,”Butter”,”Bananas”,”Apples”:

代码如下:

shoppingList[4...6] = ["Bananas", "Apples"]
// shoppingList 现在包含6个元素

注意,你不能使用下标语法在数组中添加一个元素,如果你尝试使用下标语法来获取或者设置一个元素,你将得到一个运行时的错误。尽管如此,你可以通过count属性验证索引是否正确再使用它。当count为0时(意味着数组为空),则count-1超出了索引的有效范围,因为数组的索引总是从0开始。

在一个特定的索引位置插入一个值,可以使用insert(atIndex:)方法

代码如下:

shoppingList.insert("Maple Syrup", atIndex: 0)
// shoppingList 现在包含7个元素
// "Maple Syrup" 在数组的第一位

这里调用insert方法指明在shoppingList的索引为0的位置中插入一个新元素 “Maple Syrup”

同理,你可以调用removeAtIndex方法移除特定的元素。这个方法移除特定索引位置的元素,已经返回这个被移除的元素(尽管你并不关心这个返回值)。

代码如下:

let mapleSyrup = shoppingList.removeAtIndex(0)
// 索引位置为0的元素被移除
// shoppingList 现在包含6个元素, 不包括 Maple Syrup
// mapleSyrup 常量等于被移除的 "Maple Syrup" 字符串

当元素被移除的,数组空缺的位置将会被填补,所以现在索引位置为0的元素再一次等于”Six eggs”:

代码如下:

firstItem = shoppingList[0]
// firstItem 现在等于 "Six eggs”

如果你从数组中移除最后一个元素,使用removeLast方法比removeAtIndex更方便,因为后者需要通过count属性计算数组的长度。和removeAtIndex方法一样,removeLast会返回被移除的元素。

代码如下:

let apples = shoppingList.removeLast()
//元素的最后一个元素被移除
// shoppingList 现在包含5个元素,不包括 cheese
// apples 常量 现在等于被移除的 "Apples" string

遍历数组

可以使用for-in循环来遍历数组中的值

代码如下:

for item in shoppingList {     println(item)
}
// Six eggs
// Milk
// Flour
// Baking Powder
// Bananas

如果需要每一个元素的整形的索引值,使用enumerate函数代替会更方便,enumerate函数对于每一个元素都会返回一个包含元素的索引和值的元组(tuple)。你可以在遍历部分分解元祖并储存在临时变量或者常量中。

代码如下:

for (index, value) in enumerate(shoppingList) {     println("Item \(index + 1): \(value)")
}
// 元素 1: Six eggs
// 元素 2: Milk
// 元素 3: Flour
// 元素 4: Baking Powder
// 元素 5: Bananas

如需更多for-in 循环信息, 参见 For Loops.

创建和初始化数组
创建一个空的数组和确定的类型(不包含初始化值)使用的初始化语法:

代码如下:

var someInts = Int[]()
println("someInts is of type Int[] with \(someInts.count) items.")
// prints "someInts is of type Int[] with 0 items.”

注意,someInt变量被确定为Int[],因为它使用生成Int[]的初始化方法。

或者,如果上下文(context)已经提供类型信息,例如函数参数或者已经确定类型的常量和变量,你可以从空的数组实量(Array Literals)创建一个空数组,写作[](空的中括号对)。

代码如下:

someInts.append(3)
// someInts 现在包含1个Int型的元素
someInts = []
// someInts 现在是一个空的数组, 但是类型仍然为Int[];

Swift数组类型也提供初始化方法来创建确定长度和提供默认数值的数组。你可以通过这个初始化方法增加一个新的数组,元素的数量成为count,合适的默认值为repeatedValue

代码如下:

var threeDoubles = Double[](count: 3, repeatedValue: 0.0)
// threeDoubles 的类型为 Double[], 以及等于 [0.0, 0.0, 0.0]

得益于类型推断,你并不需要指明这个数组储存的类型就能使用这个初始化方法,因为它从默认值中就能推断出来。

代码如下:

var anotherThreeDoubles = Array(count: 3, repeatedValue: 2.5)
// anotherThreeDoubles 被推断为 Double[], 以及等于 [2.5, 2.5, 2.5]

最后,你可以使用(+)操作符就能创建一个新的数组,把两个存在的数组添加进来
这个新的数组类型从你添加的两个数组中推断出来

代码如下:

var sixDoubles = threeDoubles + anotherThreeDoubles
// sixDoubles 被推断为 Double[], 并等于 [0.0, 0.0, 0.0, 2.5, 2.5, 2.5]

2、字典

字典是储存同一类型但是不同值的容器。每一个值都对应这一个唯一的键(Key),就像是字典内的每一个值都有一个标识符。和数组内的元素是有区别的,字典内的元素是没有特殊的序列的。当你需要根据标识符来查找批量的值时,就可以使用字典。同样的,真实的物品字典常常用来当作查找特定字典的标识符。

Swift字典时储存一个类型的具体的键和值,和Objective-C的NSDictionary 和NSMutableDictionary由一定的区别,因为它们是使用各种的对象来作为它们的键和值,而且并不提供任何有关对象的具体信息。在Swift中,对于一个特定的字典,它所能储存的键和值都是确定的,无论是明确声明的类型还是隐式推断的类型。

Swift的字典写法是Dictionary<KeyType,ValueType>,KeyType是你想要储存的键,ValueType是你想要储存的值。

唯一的限制就是KeyType必须是可哈希的(hashable)——就是提供一个形式让它们自身是独立识别的。Swift的所有基础类型(例如字符串(String),整形(Int),双精度(Double)和布尔(Bool))在默认是可哈希的(hashable),和这些类型都常常用语当作字典的键。枚举成员值不需要协助值(associated values)(具体描述在 Enumerations)也是因为它们默认也是可哈希的(hashable)。

字典实量(Dictionary Literals)

你可以直接用一个字典实量(Dictionary Literals)初始化一个字典。和前面定义一个数组实量(Array Literals)的语法一样。字典实量(Dictionary Literals)就是使用简略写法直接写一个或者多个的键值对来定义一个字典。

一个键值对是一个键和值的组合。在字典实量(Dictionary Literals)里面,每一个键值对总是用一个冒号把键和值分割。键值对的写法就想是一个列表,使用逗号分割,并被一对中括号[]包含着:

代码如下:

[key 1: value 1, key 2: value 2, key 3: value 3]

在下面的例子,将会创建一个字典来储存国际机场的名字。在这个字典里面,键是三个字的国际航空运送协会代码,以及它的值是机场的名称:

代码如下:

var airport :Dictionary<String, String> = ["TYO": "Tokyo", "DUB": “Dublin"]

airport字典被定义为一个类型为Dictionary<String, String>,这意味这,这个字典的键类型是字符串String,和它的值的类型也是String。

注意

airport字典是被定义为一个变量(使用var 标识符)而不是常量(使用let 标识符),所以在下面的例子可以直接添加元素。

airport字典使用一个包含两个键值对的字典实量(Dictionary Literals)来初始化。第一对由一个叫“TYO”的键和一个叫“Tokyo”的值,第二对有一个叫“DUB”的键和一个叫“Dublin”的值。

这个字典实量(Dictionary Literals)包含两个字符串(String):字符串对。这符合airport变量定义的类型(一个字典只包括字符串(String)键和字符串(String)值),所以在分配字典实量(Dictionary Literals)的时候被允许作为airport字典的两个初始化元素。

和数组一样,如果你初始化一个字典的时候使用相同的类型,你可以不指明字典的类型。
airport初始化可以用下面这个简略写法来代替:

代码如下:

var airports = ["TYO": "Tokyo", "DUB": “Dublin”]

因为所有的键在字面上都是相同的类型,同样,所有的值也是同样的类型,所以Swift可以推断为Dictionary<String, String>是airports字典的正确类型。

读取和修改字典

你可以通过属性,方法或者下标来读取和修改字典。和数组一样,你使用只读的count属性来检查字典(Dictionary)包含多少个元素。

代码如下:

println("The dictionary of airports contains \(airports.count) items.")
// prints "The dictionary of airports contains 2 items."

你可以使用下标语法给一个字典添加一个元素。使用合适类型作为新的键,并分配给它一个合适的值

代码如下:

airports["LHR"] = "London"
//  airports dictionary 现在有 3 items

你也可以使用下标语法去改变一个特定键所关联的值。

代码如下:

airports["LHR"] = "London Heathrow"
//"LHR" 的值已经被改变为 "London Heathrow"

同样, 使用字典的updateValue(forKey:) 方法去设置或者更新一个特定键的值 . 和上面的下标例子一样, updateValue(forKey:) 方法如果键不存在则会设置它的值,如果键存在则会更新它的值, 和下标不一样是, updateValue(forKey:) 方法 如果更新时,会返回原来旧的值rThis enables you to 可以使用这个来判断是否发生了更新。

代码如下:

updateValue(forKey:) 方法返回一个和字典的值相同类型的可选值. 例如,如果字典的值的类型时String,则会返回String? 或者叫“可选String“,这个可选值包含一个如果值发生更新的旧值和如果值不存在的nil值。       
if let oldValue = airports.updateValue("Dublin International", forKey: "DUB") {
println("The old value for DUB was \(oldValue).")
}
// prints "The old value for DUB was Dublin."

你也可以使用下标语法通过特定的键去读取一个值。因为如果他的值不存在的时候,可以返回他的键,字典的下标语法会返回一个字典的值的类型的可选值。如果字典中的键包含对应的值,这字典下标语法会返回这个键所对应的值,否则返回nil

代码如下:

if let airportName = airports["DUB"] {
 println("The name of the airport is \(airportName).")
 } else {
println("That airport is not in the airports dictionary.")
 }
// prints "The name of the airport is Dublin International."

你可以使用下标语法把他的值分配为nil,来移除这个键值对。

代码如下:

airports["APL"] = "Apple International"
// "Apple International" 不是 APL的真实机场,所以删除它
airports["APL"] = nil
// APL 已经从字典中被移除

同样,从一个字典中移除一个键值对可以使用removeValueForKey方法,这个方法如果存在键所对应的值,则移除一个键值对,并返回被移除的值,否则返回nil。

代码如下:

if let removedValue = airports.removeValueForKey("DUB") {
println("The removed airport's name is \(removedValue).")
} else {
println("The airports dictionary does not contain a value for DUB.")
}
// prints "The removed airport's name is Dublin International."

遍历字典

你可以使用一个for-in循环来遍历字典的键值对。字典中的每一个元素都会返回一个元祖(tuple),你可以在循环部分分解这个元祖,并用临时变量或者常量来储存它。

代码如下:

for (airportCode, airportName) in airports {
println("\(airportCode): \(airportName)")
}
// TYO: Tokyo
// LHR: London Heathrow

更多有关for-in 循环的信息, 参见 For Loops.
你也可以读取字典的keys属性或者values属性来遍历这个字典的键或值的集合。

代码如下:

for airportCode in airports.keys {
println("Airport code: \(airportCode)")
}
// Airport code: TYO
// Airport code: LHR
for airportName in airports.values {
println("Airport name: \(airportName)")
}
// Airport name: Tokyo
// Airport name: London Heathrow

如果你需要一个接口来创建一个字典的键或者值的数组实例,你可以使用keys或者values属性来初始化一个数值。

代码如下:

let airportCodes = Array(airports.keys)
// airportCodes is ["TYO", "LHR"]
let airportNames = Array(airports.values)
// airportNames is ["Tokyo", "London Heathrow"]

注意

Swift中的字典类型是非序列化集合,如果你需要序列化取回键,值,或者键值对,遍历字典不具体叙述。

创建一个空字典

和字典一样,你可以使用确定类型的语法创建一个空的字典。

代码如下:

var namesOfIntegers = Dictionary<Int, String>()
// namesOfIntegers 是一个空的 Dictionary<Int, String> 类型的字典

这个例子创建一个Int,String类型的字典来储存可读性较好的整数值。它的键是Int类型,以及它们的值是String类型。
如果 上下文(context )中已经提供类型信息,可用一个字典实量(Dictionary Literal)创建一个空的字典,写作[;](由一对[]包含一个冒号:)

代码如下:

namesOfIntegers[16] = "sixteen"
// namesOfIntegers现在包含1 个键值对
namesOfIntegers = [:]
// namesOfIntegers 是一个类型为Int, String的空字典。

注意

在这个场景,Swift数组和字典类型是一个内置的集合。更多的内置类型和集合参见Generics

3、可变集合类型

数组和字典都是在一个集合中一起储存不同的变量.如果你创建一个数组或者字典,再包含一个变量,创建的这个变量被称为可变的(mutable) 这意味这,你可以在创建之后增加更多的元素来改变这个集合的长度,或者移除已经包含的。 相反的, 如果你把一个数组或者字典定义为常量,则这个数组或者字典不是可变的,他们的长度并不能被改变。
在字典中,不可变也意味着你不能替换已经存在的键的值。一个不可变字典,一旦被设置就不能改变。
数组的不可变有一点点的不同。然而,你仍然不能做任何有可能修改不可变数组的行为。但是你可以重新设置一个已经存在的索引,这使得当Swift的数组的长度确定时,能更好地优化数组的性能。
拥有可变行为的数组也影响着数组实例的分配和修改,更多内容参见Assignment and Copy Behavior for Collection Types.

注意

在所有的例子中,这是一个好的练习去创建不可变集合,当数组的长度不需要被改变。
我确信Swift编译器能优化好你所创建的集合。

(0)

相关推荐

  • Swift中内置的集合类型学习笔记

    一.引言 Swift中提供了3种集合类型,Array数据类型,Set集合类型,Dictionary字典类型.Array用于存放一组有序的数据,数据角标从0开始一次递增:Set用于存放一组无序的数据,数据不可以重复:Dictionary也用于存放一组无序的数据,只是其是按照键值对的方式存储,键值必须唯一.这里借用官方文档中的一张图来表示3种集合类型的特点: 二.Array类型 Array通常也被称为数组,Swift是一种类型安全语言,其中的Array类型也必须确定其元素的类型,声明数组类型有两种方

  • Swift循环遍历集合的方法总结分享

    前言 之前分享总结过OC循环遍历,文章点击这里:iOS遍历集合(NSArray,NSDictionary.NSSet)方法总结.随着Swift的逐渐完善,自己使用Swift开发的项目经验和知识逐渐积累,是时候总结一下Swift的循环遍历了.相信Swift一定会给你一些不一样的东西,甚至是惊喜,感兴趣的朋友们下面来一起看看吧. 第一种方式:for-in循环 OC延续了C语言的for循环,在Swift中被彻底改造,我们无法再使用传统形式的for循环了 遍历数组和字典: //遍历数组 let iosA

  • Swift心得笔记之集合类型

    数组 重复值的初始化 除了普通的初始化方法,我们可以通过 init(count: Int, repeatedValue: T) 来初始化一个数组并填充上重复的值: 复制代码 代码如下: // [0.0,0.0,0.0] var threeDoubles = [Double](count:3,repeatedValue:0.0) 带索引值的遍历 我们可以用 for in 遍历数组,如果想要 index 的话,可以用 enumerate<Seq : SequenceType>(base: Seq)

  • Swift中定义二维数组的方法及遍历方法示例

    //定义方式一 var array1 = [[Int]]() //定义方式二 var array2 = Array<Array<Int>>() array1 = [ [13,1,4], [5,1,7,6] ] array2 = array1 // 一维数组的定义 var v = [Int]() v = [4,5,7,8] array2.append(v) println(array1) println(array2) //数组的遍历 for var i=0; i<array1

  • Swift 3.0在集合类数据结构上的一些新变化总结

    一.Array数组的更改 array数组中修改的API示例如下: //创建大量相同元素的数组 //创建有10个String类型元素的数组,并且每个元素都为字符串"Hello" //swift2.2 //var array3 = [String](count: 10, repeatedValue: "Hello") //swift3.0 var array3 = [String](repeating: "Hello", count: 10) //创

  • Swift教程之集合类型详解

    Swift 提供两种集合类型来存储集合,数组和字典.数组是一个同类型的序列化列表集合.字典是一个能够使用类似于键的唯一标识符来获取值的非序列化集合. 在Swift中,数组和字典的键和值都必须明确它的类型.这意味这数组和字典不会插入一个错误的类型的值,以致于出错.这也意味着当你在数组和字典中取回数值的时候能够确定它的类型. Swift 使用确定的集合类型可以保证代码工作是不会出错,和让你在开发阶段就能更早的捕获错误. note: Swift的数组 储存不同的类型会展示出不同的行为,例如变量,常量或

  • Swift教程之枚举类型详解

    枚举定义了一个常用的具有相关性的一组数据,并在你的代码中以一个安全的方式使用它们. 如果你熟悉C语言,你就会知道,C语言中的枚举指定相关名称为一组整数值.在Swift中枚举更为灵活,不必为枚举的每个成员提供一个值.如果一个值(被称为"原始"的值)被提供给每个枚举成员,则该值可以是一个字符串,一个字符,或者任何整数或浮点类型的值. 另外,枚举成员可以指定任何类型,每个成员都可以存储的不同的相关值,就像其他语言中使用集合或变体.你还可以定义一组通用的相关成员为一个枚举,每一种都有不同的一组

  • Swift教程之基础数据类型详解

    基础类型 虽然Swift是一个为开发iOS和OS X app设计的全新编程语言,但是Swift的很多特性还是跟C和Objective-C相似. Swift也提供了与C和Objective-C类似的基础数据类型,包括整形Int.浮点数Double和Float.布尔类型Bool以及字符串类型String.Swift还提供了两种更强大的基本集合数据类型,Array和Dictionary,更详细的内容可以参考:Collection Types. 跟C语言一样,Swift使用特定的名称来定义和使用变量.同

  • Swift教程之类与结构详解

    类与结构是编程人员在代码中会经常用到的代码块.在类与结构中可以像定义常量,变量和函数一样,定义相关的属性和方法以此来实现各种功能. 和其它的编程语言不太相同的是,Swift不需要单独创建接口或者实现文件来使用类或者结构.Swift中的类或者结构可以在单文件中直接定义,一旦定义完成后,就能够被直接其它代码使用. 注意:一个类的实例一般被视作一个对象,但是在Swift中,类与结构更像是一个函数方法,在后续的章节中更多地是讲述类和结构的功能性. 1.类和结构的异同 类和结构有一些相似的地方,它们都可以

  • Swift教程之基本运算符详解

    运算符是一种特定的符号或表达式,用来检验.修改或合并变量.例如,用求和运算符+可以对两个数字进行求和(如let i = 1 + 2):稍微复杂一点的例子有逻辑与操作符&& (如if enteredDoorCode && passedRetinaScan) ,自增长运算符 ++i (这是i=i+1的简写方式) Swift支持C标准库中的大多数运算符并提升了各自的兼容性,从而可以排除常见的编码错误.赋值操作符 (=)不会返回一个值,这样可以防止你因粗心将赋值运算符 (=)写成

  • Swift教程之类的析构详解

    在一个类的实例被释放之前,析构函数会被调用.用关键字deinit来定义析构函数,类似于初始化函数用init来定义.析构函数只适用于class类型. 1.析构过程原理 Swift 会自动释放不再需要的实例以释放资源.如自动引用计数那一章描述,Swift 通过自动引用计数(ARC)处理实例的内存管理.通常当你的实例被释放时不需要手动地去清理.但是,当使用自己的资源时,你可能需要进行一些额外的清理.例如,如果创建了一个自定义的类来打开一个文件,并写入一些数据,你可能需要在类实例被释放之前关闭该文件.

  • Swift编程之枚举类型详解

    想必写过程序的童鞋对枚举类型并不陌生吧,使用枚举类型的好处是多多的,在这儿就不做过多的赘述了.Fundation框架和UIKit中的枚举更是数不胜数,枚举可以使你的代码更易阅读并且可以提高可维护性.在Swift语言中的枚举可谓是让人眼前一亮.在Swift中的枚举不仅保留了大部分编程语言中枚举的特性,同时还添加了一些好用而且实用的新特性,在本篇文章中将领略一些Swift中枚举类型的魅力. 有小伙伴会问,不就是枚举么,有什么好说的.在Swift中的枚举怎不然,Swift中的枚举的功能要强大的多,不仅

  • python进阶教程之动态类型详解

    动态类型(dynamic typing)是Python另一个重要的核心概念.我们之前说过,Python的变量(variable)不需要声明,而在赋值时,变量可以重新赋值为任意值.这些都与动态类型的概念相关. 动态类型 在我们接触的对象中,有一类特殊的对象,是用于存储数据的.常见的该类对象包括各种数字,字符串,表,词典.在C语言中,我们称这样一些数据结构为变量.而在Python中,这些是对象. 对象是储存在内存中的实体.但我们并不能直接接触到该对象.我们在程序中写的对象名,只是指向这一对象的引用(

  • python 的集合类型详解

    目录 集合: 创建集合 集合的基本操作 集合的内建函数和方法 总结 集合: 无序不重复的元素的组合 利用集合可以删除列表中的重复项(set()唱用作去重操作) 分类:可变集合(set),不可变集合(frozenset) 创建集合 用set()函数(可变集合)或frozenset()函数(不可变集合)创建 set()   frozenset()      不可变集合是可哈希的,可变集合是可哈希的 集合的基本操作 -:为差补(离散中叫相对补)      x属于A-B等价于x属于A但x不属于B   ^

  • Swift进阶教程Mirror反射示例详解

    目录 元类型与.self AnyObject AnyClass Any type(Of:) self self在方法里面的作用 Self Swift Runtime Mirror Mirror的基本用法 Mirror的简单应用-JSON解析 Mirror源码解析 Enum Metadata探索 还原TargetEnumMetadata 还原TargetEnumDescriptor 相对偏移指针 打印枚举中的属性 Struct Metadata探索 获取结构体的属性 swift_getTypeBy

随机推荐