零基础编程入门教程_python编程入门

一、网安学习成长路线图

网安所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。
在这里插入图片描述

二、网安视频合集

观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。
在这里插入图片描述

三、精品网安学习书籍

当我学到一定基础，有自己的理解能力的时候，会去阅读一些前辈整理的书籍或者手写的笔记资料，这些笔记详细记载了他们对一些技术点的理解，这些理解是比较独到，可以学到不一样的思路。
在这里插入图片描述

四、网络安全源码合集+工具包

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。
在这里插入图片描述

五、网络安全面试题

最后就是大家最关心的网络安全面试题板块
在这里插入图片描述

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以点击这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

swift提供了元组：多个值组合成一个复合值。

元组内的值可以是任意类型，并不要求是相同类型。有了元组，函数的返回值就可以返回多个不同类型的值。

// 元组定义 // 1. 字面量定义 var tuple1 = (1, 2.0, "string", true) // 2. 带参数标签的定义 var tuple2 = (parameter1:int, parameter2:double parameter3:String) tuple2 = (1, 2.0, "string") let tuple3 = (parameter1: 1, parameter2: "string") // 元组取值 // 1. 序列号取值 tuple.0, tuple.1, tuple.2 // 2. 标签取值 tuple2.parameter1 tuple2.parameter2

3）可选类型

让程序更安全！

在OC中，有一种写法。

NSString *str = [obj getSomeStr] ?: @"";

为了保证str不是nil，在赋值时确定一下。swift提供了可选类型，来处理可能缺失的情况。注意可选类型是一个类型。

var surveyAnswer: String? = "123" // surveyAnswer 可选值为"123"" // 注意：可选类型为类型后面+？

构造器返回值可选值类型

let possibleNumber = "123" let convertedNumber = Int(possibleNumber) // 因为该构造器可能会失败，convertedNumber 被推测为类型 "Int?"， 或者类型 "optional Int" // 构造器就是构造函数, 在C++与Java中的叫法

使用if或者while可以进行判断是否有值。这个过程又叫做可选绑定

// 强制解包 let value = surveyAnswer! // 强制解包如果没值，则会crash，因此使用强制解包要保证有值 // 可选绑定 // if语法在后面介绍 if let newstring = surveyAnswer { } // 隐式展开 // 在确定有值的时候，可以直接解包 var a:Int! = 10 var b:Int = a // 疑问：已经确定有值，还用可选类型干嘛？如： // var a:Int = 10 // 解答：用可选类型是因为可以使用nil，如果不是可选类型则不能使用nil。

4）值类型与引用类型

值类型：当其进行常量、变量赋值操作，或在函数/方法中传递时，会进行值拷贝。

引用类型：增加引用计数，不进行拷贝。

5）其他

5.1)类型别名:

swift中不使用typedef , 且有等号。

typealias AudioSample = UInt16

5.2)分号:

在swift中不用使用分号, 但是在同一行的两个语句使用分号.

2.3 运算符

1）空合运算符

如果 a 包含一个值就进行解包，否则就返回一个默认值 b

a != nil ? a! : b // a必须是可选类型 //

2）区间运算符

Swift 提供了几种方便表达一个区间的值的_区间运算符_。

闭区间运算符（a...b）定义一个包含从 a 到 b（包括 a 和 b）的所有值的区间。a 的值不能超过 b。

半开区间运算符（a..<b）定义一个从 a 到 b 但不包括 b 的区间。

单侧区间运算符（a.../...b）可以表达往一侧无限延伸的区间

2.4 字符与字符串

Swift 的 String 和 Character 类型提供了一种快速且兼容 Unicode 的方式来处理代码中的文本内容, 因此可以用任何字符。有趣的是，变量或者常量命名可以采用emoji表情或者汉字。

for character in "Dog!🐶" { print(character) } // D // o // g // ! // 🐶

在书中介绍了String是基于 Unicode 标量 建立的. 因此需要了解一下Unicode中的码点, utf-8等概念. 在说到 count和objective-c的length返回的值不一样, 也是由于采取的编码格式不同.

String是值类型，对于String的使用不再赘述。

2.4 控制流

1）if

if的条件必须是一个布尔表达式——这意味着像 if score { ... } 这样的直接传值的代码将报错，swift不会隐形地与 0 做对比。

let individualScores = [75, 43, 103, 87, 12] var teamScore = 0 for score in individualScores { // swift的if语句可以像其他编程语言的一样，格式一样 // 可以采用之前的写法 if (score > 50) { // ... } // 也可以不写括号，裸奔~ if score > 50 { teamScore += 3 } else { teamScore += 1 } } print(teamScore) // guard语句对比：相当于if 相反的执行 if 条件为真 { // 执行 } guard 条件为真else { // 执行 } // guard也可以进行可选绑定 let str : String?; guard let value = str else { //解绑失败，即数据为空进入 }

2）switch

switch 支持任意类型的数据（区间、元组…………）以及各种比较操作——不仅仅是整数以及测试相等。

case还支持多个条件

let vegetable = "red pepper" switch vegetable { case "celery": print("Add some raisins and make ants on a log.") case "cucumber", "watercress": print("That would make a good tea sandwich.") case let x where x.hasSuffix("pepper"): print("Is it a spicy \(x)?") default: print("Everything tastes good in soup.") }

在 Swift 中，当匹配的 case 分支中的代码执行完毕后，程序会终止 switch 语句，而不会继续执行下一个 case 分支。这也就是说，不需要在 case 分支中显式地使用 break 语句。如果需要产生case穿透，则可以在case结束后，增加fallthrough

2.5 函数

1）函数的定义

// 定义格式 func funcName(parameters) -> returnType { function body } // 例子 func greet(person: String) -> String { let greeting = "Hello, " + person + "!" return greeting }

这里函数的格式类似JavaScript的格式，只是多了返回值类型

2）参数列表

这里重点说明参数列表。

a）参数标签和参数名称：每个函数参数都有一个_参数标签（argument label）以及一个_参数名称（parameter name）。参数标签在调用函数的时候使用；调用的时候需要将函数的参数标签写在对应的参数前面。参数名称在函数的实现中使用。默认情况下，参数名称来作为它们的参数标签。

// 参数列表 func someFunction(parameterName: Int) { // 在函数体内，parameterName 代表参数值 }

b）如果你不希望为某个参数添加一个标签，可以使用一个下划线（_）来代替一个明确的参数标签。

func someFunction(_ firstParameterName: Int, secondParameterName: Int) { // 在函数体内，firstParameterName 和 secondParameterName 代表参数中的第一个和第二个参数值 } someFunction(1, secondParameterName: 2)

c）当然也可以类似C++使用缺省参数，即就是提供默认值

func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) { // 如果你在调用时候不传第二个参数，parameterWithDefault 会值为 12 传入到函数体中。 } someFunction(parameterWithoutDefault: 3, parameterWithDefault: 6) // parameterWithDefault = 6 someFunction(parameterWithoutDefault: 4) // parameterWithDefault = 12

d）当然你还可以用可变参数来指定函数参数可以被传入不确定数量的输入值。通过在变量类型名后面加入（...）的方式来定义可变参数。可变参数的传入值在函数体中变为此类型的一个数组。例如，一个叫做 numbers 的 Double... 型可变参数，在函数体内可以当做一个叫 numbers 的 [Double] 型的数组常量。

func arithmeticMean(_ numbers: Double...) -> Double { var total: Double = 0 for number in numbers { total += number } return total / Double(numbers.count) } arithmeticMean(1, 2, 3, 4, 5) // 返回 3.0, 是这 5 个数的平均数。 arithmeticMean(3, 8.25, 18.75) // 返回 10.0, 是这 3 个数的平均数。

e）函数参数默认是常量。试图在函数体中更改参数值将会导致编译错误。如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为_输入输出参数_

定义一个输入输出参数时，在参数定义前加 inout 关键字，且这个值需要时变量而不是常量

当传入的参数作为输入输出参数时，需要在参数名前加 & 符，表示这个值可以被函数修改。

func swapTwoInts(_ a: inout Int, _ b: inout Int) { let temporaryA = a a = b b = temporaryA }

3）函数类型

函数类型就像是函数指针一样。实则，还是那句话"万物皆对象"。

在 Swift 中，每个函数都有种特定的函数类型，函数的类型由函数的参数类型和返回类型组成。使用函数类型就像使用其他类型一样。

func addTwoInts(_ a: Int, _ b: Int) -> Int { return a + b } func multiplyTwoInts(_ a: Int, _ b: Int) -> Int { return a * b } var mathFunction: (Int, Int) -> Int = addTwoInts

函数类型可以作为参数类型，返回值类型等。

2.6 闭包

1) 闭包简介

OC有Block，C++有lambda表达式，swift则有闭包。

闭包采用如下三种形式之一：

全局函数是一个有名字但不会捕获任何值的闭包
嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的匿名闭包

闭包的语法

{ (parameters) -> return type in statements } // 使用 var blockOne:(String, Int) = {(parma1:String, parma2:Int) -> void in }

// 还有很多精巧的语法 let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"] // 单行表达式闭包可以通过省略 return 关键字来隐式返回单行表达式的结果 reversedNames = names.sorted(by: { s1, s2 in s1 > s2 } ) // 直接通过 $0，$1，$2 来顺序调用闭包的参数，以此类推。 reversedNames = names.sorted(by: { $0 > $1 } ) // Swift 的 String 类型定义了关于大于号（>）的字符串实现，其作为一个函数接受两个 String 类型的参数并返回 Bool 类型的值 reversedNames = names.sorted(by: >)

另外要注意的是闭包表达式是引用类型。

2) 逃逸闭包

当一个闭包作为参数传到一个函数中，但是这个闭包在函数返回之后才被执行，我们称该闭包从函数中逃逸。当你定义接受闭包作为参数的函数时，你可以在参数名之前标注 @escaping，用来指明这个闭包是允许“逃逸”出这个函数的。

// @escaping，用来指明这个闭包是允许“逃逸”出这个函数的。 var completionHandlers: [() -> Void] = [] func someFunctionWithEscapingClosure(completionHandler: @escaping () -> Void) { completionHandlers.append(completionHandler) }

3)尾随闭包
如果你需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以将闭包书写在函数圆括号之后，函数支持将其作为最后一个参数调用。在使用尾随闭包时，你不用写出它的参数标签

func someFunctionThatTakesAClosure(closure: () -> Void) { // 函数体部分 } func mySug() { // 以下是不使用尾随闭包进行函数调用 someFunctionThatTakesAClosure(closure: { // 闭包主体部分 }) // 以下是使用尾随闭包进行函数调用 someFunctionThatTakesAClosure() { // 闭包主体部分 } }

2.7 枚举、结构体、类

1）枚举

Swift 中的枚举更加灵活，不必给每一个枚举成员提供一个值。如果给枚举成员提供一个值（称为原始值），则该值的类型可以是字符串、字符，或是一个整型值或浮点数。

// 枚举的定义 enum SomeEnumeration { // 枚举定义放在这里 // 使用 case 关键字来定义一个新的枚举成员值。 } // 枚举的定义例子 enum CompassPoint { case north case south case east case west } // 可以在一个枚举中定义一组相关的枚举成员，每一个枚举成员都可以有适当类型的关联值。 enum Barcode { case upc(Int, Int, Int, Int) case qrCode(String) } // 枚举的遍历 enum TestEnum:CaseIterable { } for item in TestEnum.allCases { }

2）结构体与类

定义语法：

struct SomeStructure { // 在这里定义结构体 } class SomeClass { // 在这里定义类 } // 结构体是值类型 // 类是引用类型 // 结构体也可以当类来使用，但是不建议 // 还要很多相同点, 但是class就是定义类的, 不过多赘述struct

注意：

继承允许一个类继承另一个类的特征
类型转换允许在运行时检查和解释一个类实例的类型
析构器允许一个类实例释放任何其所被分配的资源
引用计数允许对一个类的多次引用

3）类的属性与方法

a）属性

swift中类的属性分为存储属性与计算属性。

存储属性就是存储在特定类或结构体实例里的一个常量或变量。

class FixedLengthRange { var firstValue: Int let length: Int }

计算属性就是不直接存储值，而是提供一个 getter 和一个可选的 setter，来间接获取和设置其他属性或变量的值。

struct Point { var x = 0.0, y = 0.0 } struct Size { var width = 0.0, height = 0.0 } struct Rect { var origin = Point() var size = Size() var center: Point { get { let centerX = origin.x + (size.width / 2) let centerY = origin.y + (size.height / 2) return Point(x: centerX, y: centerY) } set(newCenter) { origin.x = newCenter.x - (size.width / 2) origin.y = newCenter.y - (size.height / 2) } } }

swift还有一个类属性，类似C++的static成员。

使用关键字 static 来定义类型属性。在为类定义计算型类型属性时，可以改用关键字 class 来支持子类对父类的实现进行重写。

struct SomeStructure { static var storedTypeProperty = "Some value." static var computedTypeProperty: Int { return 1 } } enum SomeEnumeration { static var storedTypeProperty = "Some value." static var computedTypeProperty: Int { return 6 } } class SomeClass { static var storedTypeProperty = "Some value." static var computedTypeProperty: Int { return 27 } class var overrideableComputedTypeProperty: Int { return 107 } }

b）方法

实例方法同普通方法一样，方法体可以使用self关键字

类方法在方法的 func 关键字之前加上关键字 static，来指定类型方法。类还可以用关键字 class 来指定，从而允许子类重写父类该方法的实现。

2.8 类的构造与析构

1）基础说明
类的构造与析构和C++的构造与析构类似，唯一不同的可能就是在语法上不同了。
比如：全缺省构造，默认构造等等。
列出几个比较重要的构造函数语法：

// 默认构造 init() { // 在构造函数中，如果没有明企鹅super.init()，那么系统会自动添加 // 使用KVC构造时，一定要先super.init() } // 参数构造 init(parmaterNmae : type) { // 有歧义则加self self.xxx = parmaterNmae; } init?(parmaterNmae : type){ // 可能返回空，获取时为可选类型 } // 必要构造 required init(parmaterNmae : type) { }

下面挨个举例：

class Color { let red, green, blue: Double init () { // 默认构造 } init(red: Double, green: Double, blue: Double) { // 逐一成员构造器 self.red = red self.green = green self.blue = blue } init(white: Double) { // 形参构造：同函数的参数标签一样 red = white green = white blue = white } }

2）构造代理
构造器可以通过调用其它构造器来完成实例的部分构造过程。这一过程称为构造器代理，它能避免多个构造器间的代码重复。在《effective OC2.0》中也说到，在设置构造函数的时候，提供一个基础构造方法，共其他构造使用。
由于结构体以及枚举为值类型，无法继承，它们只能代理给自己的其它构造器。

struct Rect { var origin = Point() var size = Size() init() {} init(origin: Point, size: Size) { self.origin = origin self.size = size } init(center: Point, size: Size) { let originX = center.x - (size.width / 2) let originY = center.y - (size.height / 2) self.init(origin: Point(x: originX, y: originY), size: size) } }

类则不同，它可以继承自其它类。这意味着类有责任保证其所有继承的存储型属性在构造时也能正确的初始化。

给大家的福利

零基础入门

对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。

同时每个成长路线对应的板块都有配套的视频提供：

在这里插入图片描述

因篇幅有限，仅展示部分资料

网络安全面试题

绿盟护网行动

还有大家最喜欢的黑客技术

网络安全源码合集+工具包

所有资料共282G，朋友们如果有需要全套《网络安全入门+黑客进阶学习资源包》，可以扫描下方二维码领取（如遇扫码问题，可以在评论区留言领取哦）~