第二周学习小结

概述：

本周开始系统的对Swift语法部分进行学习。
Swift是面向对象的编程，在我的理解中，面向对象编程就是首先创建一个对象，然后通过向创建的对象发送消息指令来操作对象，使之满足设计所需。在大学曾经学习过一些编程语言，但由于学习时间少，内容少，且学习目的仅是为了应付考试。所以对学习Swift并没有太多的帮助。但是曾经的学习经历让我明白学好编程需要强大的逻辑思维作基础，在编程过程中，很多时候需要你讲自然语言翻译成电脑语言，而为了精简代码，你需要对复杂的自然语言进行提炼重组，尽量让你写出的代码精简高效，具备自然语言所描述的功能且具有高度的逻辑性，这样即达到了预期的效果，又让代码变的美好。下面通过每一天的学习来进行总结。

2016.08.01

1.swift可输入类型

let myName = "龚资深"
let myClass : String
myClass = "Ios1605"
var myAge = 22
let myScore : Double 
myScore = 99.5

这里需要说明的是，swift可以输出整型数和浮点型数，以及字符串等，这些都和大多数编程语言类似，但是swift拥有强大的类型推断能力，可以直接赋值，赋值以后该变量的类型久确定。注意所有的字符都要在英文输入法的状态下才可以。

2.swift运算符

按照参与运算的元素来分，可以将swift的运算符分为一元、二元和三元运算符。

print("加法运算结果\(a + b)")
print("\(a) - \(b) = \(a - b)")
print("\(a) * \(b) = \(a * b)")
print("\(a) / \(b) = \(a / b)")
print("\(a) % \(b) = \(a % b)") //求余数

以上是算数运算符

a > b
a < b
a == b
a != b
a >= b
a <= b

以上为关系运算符

if a == b && c == d{

}
else if a == b || e == f

以上是短路运算符。即都成立为真（首行），或一个成立即可。

let c = a < b ? a : b

唯一的三元运算符
问好前面的条件为真，取冒号前面的值，否则取冒号后面的值。注意问好前打空格，否则会被认为是可空类型。

2016.08.02

元组(tuple)

用一个变量或者一个常量就能保存多项数据信息的类型

var stu = (1001, "王大锤", true, 23)
print(stu.0)
print(stu.1)
print(stu.2)
print(stu.3)

let stu: (id: Int, name: String, gender: Bool, age: Int) = (1001, "王大锤", true, 23)
print(stu.id)
print(stu.name)

存储和调用信息

(x,y) = (y,x)
print(x,y)

可以用元组来交换信息

switch选择

switch a{
case 1:
case 2:
default:
}

casei相当于入口，会根据a值的多少进入相应的窗口完成指令。注意，无论什么情况必须有defaule。

2016.08.03

循环结构

本日主要讲解了swift中的循环结构，主要分为三大类，即for循环，while循环和repeat-while循环。

for i in 1..<10{
    print("\(i).hello world")
} cewwasz
for _ in 1...10{     //省略了参数
    print("hello world")
}

for循环主要针对需要满足一定循环次数的需求，比如很明确的需要尽心多少次循环，需要对某些事物进行便利的时候，其条件布明显则选用for循环

var i = 0
while i < 10{
    print("hello world")
    i += 1
}

while循环，在满足while后面的条件的情况下就会循环，这种循环结构在条件明确的情况下，可以选用，一直到条件不再成立为止

var i = 0
repeat{
    print("hello world")
    i += 1
}while i < 10

与while循环不一样的是，无论条件是什么，该循环都会无条件执行一次，然后再判断条件是否还成立，成立的话就继续循环，不成立久终止循环。

2016.08.04

程序就是指令的结合，而再复杂的程序也是基于简单的循环选择分支等结构组成的。老师重点让我们掌握了四个小程序

1.赌博

func roll() -> Int{
    return Int(arc4random_uniform(6)) + 1
}

var money = 1000

repeat{
    print("玩家总资产：¥\(money)元")
    var debt : Int
    repeat{
        print("请下注:", terminator:" ")
        debt = inputInt()
    }while debt <= 0 || debt > money

    var needsGoOn = false
    let firstPoint = roll() + roll()
    print("玩家摇出了\(firstPoint)点")
    switch firstPoint{
    case 7, 11:
        money += debt
        print("玩家胜")
    case 2,3,12:
        money -= debt
        print("庄家胜")
    default:
        needsGoOn = true
    }

    while needsGoOn{
        let currentPoint = roll() + roll()
        print("玩家摇出了\(currentPoint)点")
        if currentPoint == 7{
            money -= debt
            print("庄家胜")
            needsGoOn = false
        }
        else if currentPoint == firstPoint{
            print("玩家胜")
            money += debt
            needsGoOn = false
        }
    }
}while money > 0
if money <= 0
{
    print("你破产了")
}

在这段程序中，核心的矛盾是，第一次摇出的两个数之和为7和11时，玩家胜利；为2，3，12时庄家胜，若为其他数则继续摇，摇到7时庄家胜，摇到于第一次摇的一样的数时玩家胜。因此我们应该先写出第一次摇的情况。仔细琢磨一下，只是一次分情况的摇，不用循环，且分支结构明显，所以选用switch完成第一次摇的情况，如下：

switch firstPoint{
    case 7, 11:
        money += debt
        print("玩家胜")
    case 2,3,12:
        money -= debt
        print("庄家胜")
    default:
        needsGoOn = true
    }

这里的needgoon是表示，如果第一次摇没有结束游戏，就要进行下一次。注意这是一个条件，且不需要无条件进行第一次，所以选用while来进行接下来的摇数：

 while needsGoOn{
        let currentPoint = roll() + roll()
        print("玩家摇出了\(currentPoint)点")
        if currentPoint == 7{
            money -= debt
            print("庄家胜")
            needsGoOn = false
        }
        else if currentPoint == firstPoint{
            print("玩家胜")
            money += debt
            needsGoOn = false
        }
    }

先梳理好思路，找到主要矛盾，完成主要的代码部分，再进行修饰，加入赌金本金之类的，就完成了这一段代码

2.猜数字

func roll() -> Int{
    return Int(arc4random_uniform(99)) + 1
}
var yournum : Int
let compnum = roll()
repeat{
    print("请输入你的数字：")
    yournum = inputInt()
    if yournum > compnum{
    print("little")
    }
    else if yournum < compnum{
    print("more")
    }
    else{
    print("good")
    }
}while yournum != compnum

这段代码用了if else的分支结构，主要作用是用于单一方面的条件，成立如何，不成立如何。当然也可以有多个if语句。

2016.08.05

1.数组

var array1 = [Int]()//空数组
var array: [Int] = []//空数组
var array3 = [99, 12, 34, 156, 7]
var array4 = [Int](count: 100, repeatedValue: 1)
var array5 = [String]()
var array6 = [String](count: 4, repeatedValue: "kkk")
var array7 = [";;", "kkk", "djiwodj"]

数组的创建有多种方法，但直接复制法（3）和指定数量（4）用的较多

print(array7.count)

获取数组元素个数

for index in 0..<array7.count{
    //[]是对数组进行下标(索引)运算(取出指定位置的元素)
    print(array7[index])
    if index == 1{
        array7[index] = "de"
    }
}
//只读循环(每个元素都要遍历，在循环过程中不能修改数组元素)
for str in array7{
    print(str)
}

对数组中的元素进行遍历

array1.append(1)
array1.append(3) // 追加，放在前一个的后面
array1.insert(4, atIndex: 0)// 插入，前面是值，后面是位置参数
array1.insert(7, atIndex: array1.count) //插到最后一个

向数组中添加元素

array1.removeAll()
array1.removeAll(keepCapacity: <#T##Bool#>)// true久只删数据，保留空间
array1.removeAtIndex(<#T##index: Int##Int#>) //删指定位置的
array1.removeFirst() //删第一个
array1.removeFirst(<#T##n: Int##Int#>) //删前面n个

删除的方法还有很多，这里是一部分

let array8 = array7  //复制全部
var array9 = array7[1...2] // [1..<2] // 复制一部分

数组的复制

let array10 = array1 + array3

同种类型数组相加,可以合并

数组是对大量数据进行操作的有效方法，通过运用数组和循环选择等结构的组合应用，通过简单的代码完成复杂的问题。

接前一天的四个程序，接下来的两个就摇用到数组

2.冒泡排序

var array = [44, 78, 2, 39, 89, 12, 66]
for j in 0..<array.count - 1{
    var stop = false
    for i in 0..<array.count - 1 - j{
        if array[i] > array[i + 1] {
            (array[i], array[i + 1]) = (array[i + 1], array[i])
            stop = true
        }
    }
    if !stop{
        break
    }
}
print(array)

冒泡法排序的核心矛盾是两两比较，将两者中较大的数换到后面去，然后每遍历一次就将一个最大的数放在最后。写stop是当检测到没有交换但循环未完，提前结束循环保证效率。

3.简单选择

var array = [44, 78, 2, 39, 89, 12, 66] 
for i in 0..<array.count - 1{
    var minIndex = i
    for j in i + 1..<array.count{
        if array[j] < array[minIndex]{
            minIndex = j
        }
    }
    (array[i], array[minIndex]) = (array[minIndex], array[i])
}
print(array)
}

简单选择是首先确定一个存放目标值的变量，这里为minindex，然后初始默认与i代表的数一致，通过j对i以后的数进行遍历，当找到比minindex更小的数以后，讲minindex的值（这里的值表示数组的索引号，初始为i）与j代表的索引号交换，第一次循环完后minindex索引代表的值就是数组的最小值，再遇第一个值交换，然后i＝ i+1，接着继续做同样的事，指示循环次数减少1。

4.百鸡百元

for i in 0...20{
    for j in 0...33{
        let n = 100 - i - j
        if n % 3 == 0 && i * 5 + j * 3 + n / 3 == 100{
            print(i,terminator: " ")
            print(j,terminator: " ")
            print(n)
        }
    }
}

这是一个穷举法，将所有情况遍历一次，求解。值得注意的是，第三个调节写成循环时，程序会因为不够优化而报错。这也告诉我们要学会优化程序。