第7章 函数——C++的编程模块

定义函数

• 可以将函数分成两类：没有返回值的函数和有返回值的函数
• 对于有返回值的函数，必须有返回语句
• C++对于返回值的类型有一定限制：不能是数组，但可以是其他任何类型——整数、浮点数、指针、结构体和对象。
• 函数的返回值过程：
  • 函数通过将返回值复制到指定的CPU寄存器或内存单元中来将值返回。
  • 调用程序将查看该内存单元。
• 函数在执行返回语句后结束。如果函数包含多条返回语句，则函数在执行遇到的第一条返回语句后结束

函数原型和函数调用

1
2
3
4

#include<iostream>

void cheers(int n);
double cube(double x);

• 原型描述了函数到编译器的接口，也就是说，它将返回值的类型以及参数的类型和数量告诉了编译器。
• 原型的功能：
  • 编译器正确处理函数的返回值
  • 编译器检查使用的参数数目是否正确
  • 编译器检查使用的参数类型是否正确，如果不正确，则转换成正确的类型（如果可能的话）。
• 仅当有意义时，原型化才会导致类型转换。
• 在编译阶段进行的原型话被称为静态类型检查（static type checking）

函数如何使用指针来处理数组

• C++和C一样，也将数组名视为指针。C++将数组名解释为其第一个元素的地址。
• 规则的例外：
  • 数组声明使用数组名来标记存储位置
  • 对数组名使用 sizeof 将得到整个数组的长度（以字节为单位）
  • 将地址运算符 & 用于数组名时将返回整个数组的地址。
• 为防止函数无意中修改数组的内容，可在声明形参时使用关键字 const
  • 这并不意味着原始数组必须是常量，而只是意味着不能在函数中使用数组指针变量来修改这些数据。（如果尝试修改，则编译器会报错）

指针和 const

• 可以用两种不同的方式将 const 关键字用于指针。
  • 让指针指向一个常量对象，这样可以防止使用该指针来修改所指向的值
  • 将指针本身声明为常量，这样可以防止改变指针指向的位置

1
2

int age = 39;
const int *pt = &age;

• pt 指向一个 const int ，因此不能使用 pt 来修改这个值。
• 可以直接通过 age 变量来修改 age 的值，但不能使用 pt 指针来修改它

1
2

*pt = 20; // INVALID bevause pt points to a const int
age = 20; // VALID because age is not declared to be const

• 不能将 const 变量的地址赋给常规指针

1
2
3
4
5

const fload g_earth = 9.80;
cosnt float * pe = &g_earth; // VALID

const float g_moon = 1.63;
float * pm = &g_moon; // INVALID

• 第一种情况：既不能用 g_earth 来修改值 9.80，也不能使用 pe 来修改。C++禁止第二种情况，因为不能用 pm 来修改 g_moon

• 如果涉及一级间接关系，则将非 const 指针赋值给 const 指针是可以的

1
2
3

int age = 39; // age++ is a valid operation
int* pd = &age; // *pd = 41 is a valid operation
const int* pt = pd; // *pt = 42 is a invalid operation

1
2
3
4
5
6

const int **pp2;
int *p1;
const int n = 14;
pp2 = &p1; // not allowed but suppose it were
*pp2 = &n; // valid, both const, but sets p1 to point at n;
*p1 = 10; // valid, but changes const n

• 仅当只有一层间接关系（如指针指向基本数据类型时），才可以将非 const 地址或指针赋值给 const 指针。

• 禁止将常量数组的地址赋给非常量指针意味着不能将数组名作为参数传递给使用非常量形参的函数。

1
2
3
4

const int cArr = {1, 2, 3, 4};
int sum(int arr[], int n)
...
int j = sum(cArr, 4); // not allowed

• 禁止将指针参数声明为指向常量数据的指针有两条理由：
  • 可以避免由于无意间修改数据而导致编程错误
  • 使用 const 使得函数能够处理 const 和非 const 实参，否则只能接受非 const 数据。如果条件允许，则应将指针形参声明为指向 const 的指针。

函数和结构

• 定义结构体

1
2
3
4
5
6
7
8
9
10
11
12
13
14

struct travel_time {
int hours;
int mins;
};

travel_time sum(travel_time t1, travel_time t2) {
    const int Mins_per_hr = 60;
    travel_time total;

    total.mins = (t1.mins + t2.mins) % Mins_per_hr;
    total.hours = t1.hours + t2.hours + (t1.mins + t1.mins) % Mins_per_hr;

    return total;
}

其他定义结构体的例子

1
2
3
4
5
6
7
8
9

struct polar {
double distance;
double angle;
};

struct rect {
double x;
double y;
};

• while 循环同时读取两个变量

1
2
3

while (cin >> rplace.x >> rplace.y) {
cout << rplace.x << ' ' << rplace.y;
}

• cin 是 istream 类的一个对象。抽取运算符 >> 被设计成使得 cin >> rplace.x 也是一个 istream 对象。

传递结构的地址 （结构体指针）

• 假设要传递结构的地址而不是整个结构以节省时间和空间，则需要修改函数：

  • 调用函数时，将结构的地址 &pplace 而不是结构本省 pplace 传递给函数

  • 将形参声明为指向 polar 的指针，即 polar* 类型。由于函数不应该就该结构，因此使用了 const 修饰符

  • 形参是指针而不是结构，因此应使用间接成员运算符 -> ，而不是 .

    1 2 3 4 5 6 7 8 9 10 11 12 13

    void show_polar (const polar* pda) { using namespace std; const double Rad2deg = 57.29577951; cout << "distance = " << pad->distance; cout << ", angle = " << pad->angle * Rad2deg; cout << " degrees\n"; } int main() { ... show_polar(&pplace); }

  • 函数使用的是指针，是的函数能对原始结构进行操作

函数和 string 对象

• 函数读取 string 对象数组

1
2
3
4
5
6
7

int main() {
const int SIZE = 5;
string list[SIZE];
for (int i = 0; i < SIZE; i++) {
getline(cin, list[i]);
}
}

函数和 array 对象

• array 对象的定义

1
2

std::arrray<double, 4> expenses;
fill(&expenses, 0);

递归

函数指针

• 与数据项相似，函数也有地址。函数的地址是存储其机器语言代码的内存的开始地址。
• 可以编写将另一个函数的地址作为参数的函数。这样第一个函数就能找到第二个函数，并运行它。

声明函数的指针

1
2

double pam(int); // 函数原型
double (*pf)(int); // 函数指针 pf, 函数输入为一个 int 数字，输出为一个 double

函数的传递 - 函数的地址与函数的返回值

1
2

process(think); // passes address of think() to process()
thought(think()); // passes return value of think() to thought

函数指针的声明和赋值

1
2
3
4
5
6
7
8
9
10
11
12
13
14

double pam(int)
double (*pf)(int);
pf = pam;

int ted(int)
int ned(double)
pf = ted; // invalid
pf = ned; // invalid

const double * f1(const double ar[], int n);
const double * (*p1)(const double *, int);
p1 = f1;

auto p1 = f1;

• 使用指针来调用函数

1
2
3
4
5
6
7
8
9

double best(int)

void estimate(int lines, double (*pf)(int)) {
cout << (*pf)(lines) << " hour(s)\n";
}

int main() {
esitimate(code, best);
]

1
2
3
4
5

double pam(int);
double (*pf)(int);
pf = pam;
double x = pam(4); // call pam() using the function name
double y = (*pf)(5); // call pam() using the pointer pf

• 函数指针的数组

1

const double * (*pa[3]) (const double *, int) = {f1, f2, f3};

• 这里不能使用 auto ，自动类型推断只能用于单值初始化，而不能用于列表初始化

深入探讨函数指针

1
2
3
4
5
6
7
8
9

const double * f1(const double ar[], int n);
const double * f2(const double [], int);
const double * f3(const double *, int);

const double * (*p1)(const double *, int) = f1;
auto p2 = f2; // c++11 automatic type deduction

cout << (*p1)(av,3) << ": " << *(*p1)(av, 3) << endl;
cout << p2(av,3) << ": " << *p2(av, 3) << endl;

• 这里 p1, p2 都调用了指向的函数。在每条 cout 语句中，前半部分显示存储函数返回值的地址。后半部分为存储在这些地址里的实际返回值。

• 指向函数数组的指针初始化

1
2
3
4

const double * (*pa[3]) (const double *, int) = {f1, f2, f3};

auto pc = &pa; // c++ 11 automatic type deduction
const double *(*(*pd)[3])(const double *, int) = &pa;

用 typedef 进行简化

1
2
3
4
5
6
7

typedef double real; // make real another name for double

typedef const double *(*p_fun)(const double *, int); // p_fun now a type name
p_fun p1 = f1; // p1 points to the f1() function

p_fun pa[3] = {f1, f2, f3};
p_fun (*pd)[3] = &pa;

2020

活在这珍贵的人间
人类像植物一样幸福
爱情像雨水一样幸福
——海子

其实说到2020年，我也没有什么想要总结的，因为实在没有什么可以总结的事。因为疫情，每一个人的生活都改变了。生活的唯一目的变成了：活下去。惟愿每一个人都能健康幸福。

2020年，每一个活在世上的人都是幸运的受难者。

2020目标完成情况

1. 搭建一个自己的博客，坚持写：基本完成了。
2. 每周跑步10km：因为疫情，把跑步替换成了跳绳、有氧拳击，基本完成。
3. 自学日语（2019年断断续续背了一些单词了，希望2020过完可以能到N3或者N2的水平）：没有完成，搁置了。
4. 至少读24本书，完成阅读任务：读书31本，除了希望读两本英文书的目标只读了1.5本。
5. 至少看50部电影：完成了。
6. 自学pr，剪出一个自己满意的vlog（我看悬）：没有完成。
7. 保证每天的8h睡眠考试周及前一周除外：基本完成。还是有熬夜的时候。
8. 去一个想去的地方旅行（我看悬）：没有完成。
9. 有空的时候练练字（不强求）：完成了。

• 2020 喜欢的书：
  

  • 《王小波全集：第一卷、第二卷 杂文》王小波：王小波真是一个特别让我觉得相见恨晚的作家。他的杂文尤其出色，我喜欢他幽默的语言、清晰的思路、尖锐的讽刺。王小波的文章告诉了我们：生活中有很多很多美好的事情：平等、自由、博爱、理性、诚实。有很多很多的道理，也许不会出现在课本里，也不会出现在老师的课堂上，甚至有一些人不希望我们知道，但那确实是让人生真正幸福的唯一办法。
  • 《在水中热爱火焰》 【葡萄牙】安德拉德：一本名字就很美的诗集。爱是人间至苦的一味解药。
  • 《当我谈跑步时我谈些什么》 【日】村上春树：对于很多事情来说，重要的是坚持这一行为本身，而最后的结果会如何这一点，已经不那么重要了。“我现在认识到，生存的质量并非成绩、数字、名次之类固定的东西，而是含于行动之中的流动性的东西”。
  • 《何为良好生活：行之于途而应于新》 陈嘉映:一本并不太好读但是内容深刻的哲学书。 书的标题是何为良好生活，但其实这本书也没有给出一个明确的答案，而是给如何思考这个问题给出了一些提示。在我的理解中，良好生活并不是一个固定的、让人效仿的范式，不是一个明确的行为清单，而是我们在人生的前行中逐步努力追求一个未知的、因人而异的美好愿景的过程。
  • 《身份的焦虑》 【英】阿兰·德波顿：焦虑就像是现代社会对现代人的pua，平等意识告诉我们人与人的都是相似的，你与周围的人处境的差别都是个人努力不同的结果。言下之意就是，如果你觉得自己过得不好，那就是你不够努力（但事实上并不是这样的）。精英崇拜和过度期望使得我们总是给自己应允了很多不切实际的东西，比如说某些成就，某些社会地位，但那些其实并不是我们所需要的。 我觉得焦虑是现代社会的常态，它没有彻底的解药，也不需要解药（适当的焦虑是有益的）。我们要做的，是认识自我，宽容自身的缺陷，找到自己真正需要的东西。

• 2020 喜欢的电影：
  

  • 我们俩 / You and Me 马俪文 (2005)：小成本的人情故事。
  • 极速车王 / Ford v Ferrarri 詹姆斯·曼高德 (2019): 激动人心，手掌冒汗。
  • 小鞋子 / بچههای آسمان 马基德·马基迪 (1997): 孩子们的眼睛太会说话了。
  • 婚姻故事 / Marriage Story 诺亚·鲍姆巴赫 (2019): 一个让人难过又绝望的故事：明明两个人都没有什么错，只是因为各自的追求而让婚姻与理想中的生活如此格格不入。其实也可以不离婚的，只不过整个事情从一开始就再也没有回头路了。
  • 她 / Her 斯派克·琼斯 (2013):孤独所创造出来的精神世界就像毒品一样，如果上瘾了，就会沉溺其中，无法自拔。可是当我们从自我安慰的美梦中猛然惊醒，会感到巨大的无力感和空虚感交杂在一起，就好像整个世界都在离我们远去。

• 2020喜欢的电视剧：
  

  • 我爱我家 (1993): 中国最好的情景喜剧。

新年愿望

1. 坚持写博客，学习笔记以及其他。
2. 每周5小时高强度的有氧运动，保持体重。
3. 自学日语
4. 至少读40本书，完成阅读任务
5. 至少看50部电影
6. 领养一只猫
7. 保证每天晚上11点30分前睡觉
8. 有空的时候练字和画画（不强求）
9. 每天写日记

2020的阅读任务

1. 至少读5本去年没读过的作者的书
2. 至少读完2本大部头
3. 至少读5本想读列表内2015年前标记的书
4. 至少读2本英文原版书
5. 至少读4本往年诺奖得主的作品

阴晴圆缺都休说，且喜人间好时节。好时节，愿得年年，常见中秋月。

– 徐有贞《中秋月》

JavaScript Basic

Comment Your Code

注释的两种方式:

1. 双斜线的单行注释//

1

// This is an in-line comment

1. 斜线星号的多行注释

1
2

/* This is a
multi-line comment */

Declare JavaScript Variables

声明变量：
JS里一共有7种变量类型：undefined, null, boolean, string, symbol, number, object
在JS中使用 var 来声明变量

1

var ourName

Storing Values with the Assignment Operator

用等号给变量赋值, 赋值运算总是从右往左进行，等号右边的最终计算结果被赋予等号左边的变量

1

myVar = 5;

Initializing Variables with the Assignment Operator

在声明变量时，给变量赋值初始化

1

var myVar = 0; // Creates a new variable called myVar and assigns it an initial value of 0

Understanding Uninitialized Variables

当变量被声明时，他的初始值（如果没有手动设置初值）为undefined

1
2
3
4
5
6
7

var a;
var b;
var c;

a = a + 1; // NaN
b = b + 5; // NaN
c = c + " String!"; // undefined String!

Understanding Case Sensitivity in Variables

在设置变量名时，编译器会区别变量名的大小写。所以当有两个变量的变量名字母相同，但大小写不同时，我们就要注意区分其中的区别。一般情况下，我们不推荐用大小写来区分不同的变量（除非有一些默认常量值，用全部的大写字母表示）

Arithmetic Operate Two Numbers with JavaScript

加减乘除四则运算

1
2
3
4

var sum = 5 + 10; // assigned 15
var sub = 10 - 5; // assigned 5
var mult = 10 * 5; // assigned 50
var div = 10 / 5; // assigned 2

Increment/Decrement a Number with JavaScript

自加减1

1
2

i++; // i = i + 1;
i--; // i = i - 1;

Create Decimal Numbers with JavaScript

JS的变量可以储存小数，小数通常被当作 floating point numbers,floats

1

var myDecimal = 5.7;

Finding a Remainder in JavaScript

整数除法求商和余数

1
2
3

var myNum = 5; 
myNum % 2 = 1;
Math.floor(5 / 2) = 2; //Math.floor(x) 对x向小取整

Declare String Variables

声明字符串变量

1

var myStr = "Hello";

Escaping Literal Quotes in Strings

字符串中的一些转义字符

转义字符

1

var sampleStr = "Alan said, \"Peter is learning JavaScript\".";

Quoting Strings with Single Quotes

在JavaScript 中，单引号和双引号都可以表示字符串变量，且效果相同

Concatenating Strings

用加号来连接字符串

1
2
3
4

'Hello '+'World'; // "Hello World"

var myStr = 'Hello ';
myStr += 'World'; // "Hello World"

Find the Length of a String

求字符串的长度 string.length 返回长度值（包括空格）

1

"Alan Peter".length; // 10

Use Bracket Notation to Find the First Character in a String

用[]索引字符串中的某个字符
首字母：

1
2

var firstName = "Charles";
var firstLetter = firstName[0]; // firstLetter is "C"

第n个字母（索引值为 n-1）：

1
2

var firstName = "Ada";
var secondLetterOfFirstName = firstName[1]; // secondLetterOfFirstName is "d"

最后一个字母(用length得到字符串长度)：

1
2

var firstName = "Charles";
var lastLetter = firstName[firstName.length - 1]; // lastLetter is "s"

Understand String Immutability

在JS中，String 类型中的某个字符是不能改变的，只能将整个变量重新赋值

1
2

var myStr = "Bob";
myStr[0] = "J"; //报错

正确的修改方法为：

1
2

var myStr = "Bob";
myStr = "Job";

Store Multiple Values in one Variable using JavaScript Arrays

用阵列储存多个数据：

1

var sandwich = ["peanut butter", "jelly", "bread"].

Nest one Array within Another Array

阵列的元素可以是子阵列，这样的阵列也叫多维阵列，可以使用索引读取和修改数据：

1
2
3

var myArray = [["Bulls", 23], ["White Sox", 45]];
myArray[1][0]; // "White Box"
myArray[1][1] = 55; // ["Bulls", 23], ["White Sox", 55]

Manipulate Arrays With push(), pop(), shift(), unshift()

array.push(x) 把x加到阵列的最后一位，函数返回值为array的元素个数
array.pop() 移除阵列的最后一个元素，返回最后一个元素的值
array.shift() 移除阵列的第一个元素，返回这个元素的值
array.unshift(x) 把x加到阵列的第一位，函数返回值为array的元素个数

Write Reusable JavaScript with Functions

JS的方程示例

1
2
3

function functionName(input) {
  console.log(input);//方程执行的内容
}

Global Scope and Functions

在JS中， 在方程外定义的变量是全局可见的，方程内的局部变量在另一个方程里为undefined

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

var myGlobal = 1;

function fun1() {
  // Assign 5 to oopsGlobal Here
var oopsGlobal = 5;
}

function fun2() {
  var output = "";
  if (typeof myGlobal != "undefined") {
    output += "myGlobal: " + myGlobal;
  }
  if (typeof oopsGlobal != "undefined") {// 不会执行，因为局部变量没有定义
    output += " oopsGlobal: " + oopsGlobal;
  }
  console.log(output); // myGlobal: 1
}

Local Scope and Functions

局部变量在方程之外是不可见的

1
2
3
4
5
6
7

function myLocalScope() {
  'use strict';
  console.log('inside myLocalScope', myVar);
}
myLocalScope();
console.log('outside myLocalScope', myVar);
// ReferenceError: myVar is not defined

Global vs. Local Scope in Functions

如果全局变量和局部变量重名，那么优先使用方程内部的局部变量，但是全局变量不会因此被修改。

1
2
3
4
5
6
7

var someVar = "Hat";
function myFun() {
  var someVar = "Head";
  return someVar; // return "Head"
}

console.log(someVar) // Hat

Return a Value from a Function with Return

你可以设置函数变量把参数传递给局部变量，也可以使用 return 把参数传递回方程外部：

1
2
3
4

function plusThree(num) {
  return num + 3;
}
var answer = plusThree(5); // 8

Understanding Undefined Value returned from a Function

一个函数可以有 return 声明，也可以没有。当一个函数没有return时，它的返回值是undefined

1
2
3
4
5

var sum = 0;
function addSum(num) {
  sum = sum + num;
}
addSum(3); // sum will be modified but returned value is undefined

Assignment with a Returned Value

函数的返回值通过等号赋值给变量：

1

ourSum = sum(5, 12);// ourSum = 17;

Understanding Boolean Values

布尔型变量， 布尔型变量只有两种：true 和 false

Use Conditional Logic with If Statements

If 语句的写法和条件分支情况：

1
2
3
4
5
6
7
8
9
10
11
12

if (condition is true) {
  statement is executed
}
// Example
function test (myCondition) {
  if (myCondition) {
     return "It was true";
  }
  return "It was false";
}
test(true);  // returns "It was true"
test(false); // returns "It was false"

Comparison with the Equality Operator

比较：相等的情况，相等 ==，强等于 ===

1
2
3
4
5
6

function equalityTest(myVal) {
  if (myVal == 10) {
     return "Equal";
  }
  return "Not Equal";
}

比较：强等于情况下字符串变量不会转化成数字

1
2

3 ===  3   // true
3 === '3'  // false\

比较：不等于 !=

1
2
3
4
5

1 !=  2     // true
1 != "1"    // false
1 != '1'    // false
1 != true   // false
0 != false  // false

比较：强不等于 ! ==

1
2
3

3 !==  3   // false
3 !== '3'  // true
4 !==  3   // true

比较：大于 >

1
2
3
4

5   >  3   // true
7   > '3'  // true
2   >  3   // false
'1' >  9   // false

比较：大于或等于 > =

1
2
3
4

6   >=  6   // true
7   >= '3'  // true
2   >=  3   // false
'7' >=  9   // false

比较：小于 <

1
2
3
4
5

2   < 5  // true
'3' < 7  // true
5   < 5  // false
3   < 2  // false
'8' < 4  // false

比较：小于或等于 < =

1
2
3
4
5

4   <= 5  // true
'7' <= 7  // true
5   <= 5  // true
3   <= 2  // false
'8' <= 4  // false

Comparisons with the Logical And Operators

逻辑运算符：与 and

1
2
3
4

if (num > 5 && num < 10) {
  return "Yes";
}
return "No";

逻辑运算符：或 or

1
2
3
4

if (num > 10 || num < 5) {
  return "No";
}
return "Yes";

Introducing Else, Else if Statements

当条件判断结果为 false, 使用 else 和 else if 来表示其他的分支情况：

1
2
3
4
5

if (num > 10) {
  return "Bigger than 10";
} else {
  return "10 or Less";
}

1
2
3
4
5
6
7

if (num > 15) {
  return "Bigger than 15";
} else if (num < 5) {
  return "Smaller than 5";
} else {
  return "Between 5 and 15";
}

Chaining If Else Statements

把 if else 语句连接起来

1
2
3
4
5
6
7
8
9
10

if (condition1) {
  statement1
} else if (condition2) {
  statement2
} else if (condition3) {
  statement3
. . .
} else {
  statementN
}

Selecting from Many Options with Switch Statements

使用 Switch 语句从一个判断条件的多种情况中选择：

1
2
3
4
5
6
7
8

switch(lowercaseLetter) {
  case "a":
    console.log("A");
    break;
  case "b":
    console.log("B");
    break;
}

添加默认情况：

1
2
3
4
5
6
7
8
9
10
11
12

switch (num) {
  case value1:
    statement1;
    break;
  case value2:
    statement2;
    break;
...
  default:
    defaultStatement;
    break;
}

当多种情况结果相同时，可以将代码简化省略：

1
2
3
4
5
6
7
8
9

switch(val) {
  case 1:
  case 2:
  case 3:
    result = "1, 2, or 3";
    break;
  case 4:
    result = "4 alone";
}

Build JavaScript Objects

建立 JS 对象，对象变量和数组类似，但是在取得和修改对象中的数据时，我们会用到对象的属性 properties.

1
2
3
4
5
6

var cat = {
  "name": "Whiskers",
  "legs": 4,
  "tails": 1,
  "enemies": ["Water", "Dogs"]
}

我们用“.”记号来获得对象的属性值：

1
2
3
4
5
6

var myObj = {
  prop1: "val1",
  prop2: "val2"
};
var prop1val = myObj.prop1; // val1
var prop2val = myObj.prop2; // val2

我们也可以用方括号“[ ]” 来读取数据：

1
2
3
4
5
6
7
8

var myObj = {
  "Space Name": "Kirk",
  "More Space": "Spock",
  "NoSpace": "USS Enterprise"
};
myObj["Space Name"]; // Kirk
myObj['More Space']; // Spock
myObj["NoSpace"];    // USS Enterprise

更新对象的属性：

1
2
3
4
5
6
7
8

var ourDog = {
  "name": "Camper",
  "legs": 4,
  "tails": 1,
  "friends": ["everything!"]
};
ourDog.name = "Happy Camper";
ourDog["name"] = "Happy Camper";

添加新属性：

1
2

ourDog.bark = "bow-wow";
ourDog["bark"] = "bow-wow";

删除属性：

1
2
3
4
5
6
7
8
9

var ourDog = {
  "name": "Camper",
  "legs": 4,
  "tails": 1,
  "friends": ["everything!"],
  "bark": "bow-wow"
};

delete ourDog.bark;

Testing Objects for Properties

为了测试对象是否存在某一属性， 我们可以使用命令 .hasOwnProperty(proname) . 函数会返回布尔值。

1
2
3
4
5
6

var myObj = {
  top: "hat",
  bottom: "pants"
};
myObj.hasOwnProperty("top");    // true
myObj.hasOwnProperty("middle"); // false

Accessing Nested Objects

当对象变量较为复杂，层层嵌套时，可以一层层读取：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

var ourStorage = {
  "desk": {
    "drawer": "stapler"
  },
  "cabinet": {
    "top drawer": { 
      "folder1": "a file",
      "folder2": "secrets"
    },
    "bottom drawer": "soda"
  }
};
ourStorage.cabinet["top drawer"].folder2;  // "secrets"
ourStorage.desk.drawer; // "stapler"

对于多维对象阵列，可以使用同样的方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

var ourPets = [
  {
    animalType: "cat",
    names: [
      "Meowzer",
      "Fluffy",
      "Kit-Cat"
    ]
  },
  {
    animalType: "dog",
    names: [
      "Spot",
      "Bowser",
      "Frankie"
    ]
  }
];
ourPets[0].names[1]; // "Fluffy"
ourPets[1].names[0]; // "Spot"

Iterate with JavaScript Loops

while 循环：

1
2
3
4
5
6
7

var ourArray = [];
var i = 0;
while(i < 5) {
  ourArray.push(i);
  i++;
}
// ourArray = [0, 1, 2, 3, 4]

for 循环:

1
2
3
4
5

var ourArray = [];
for (var i = 0; i < 5; i++) {
  ourArray.push(i);
}
// ourArray = [0, 1, 2, 3, 4]

do … while 循环：

1
2
3
4
5
6

var ourArray = [];
var i = 0;
do {
  ourArray.push(i);
  i++;
} while (i < 5);

Replace Loops using Recursion

使用递归代替循环：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

function multiply(arr, n) {
    var product = 1;
    for (var i = 0; i < n; i++) {
        product *= arr[i];
    }
    return product;
  }

function multiply(arr, n) {
    if (n <= 0) {
      return 1;
    } else {
      return multiply(arr, n - 1) * arr[n - 1];
    }
  }

Generate Random Fractions with JavaScript

生成随机数：Math.randon() 会生成一个0（包括）到1（不包括）之间的数：

生成一个整数：

1
2
3

1. Use Math.random() to generate a random decimal.
2. Multiply that random decimal by 20.
3. Use another function, Math.floor() to round the number down to its nearest whole number.

在范围[a,b] 之间生成随机数：

1

Math.floor(Math.random() * (max - min + 1)) + min

Use the parseInt Function

方程 parseInt() 将字符串转化为整型数字：

1

var a = parseInt("007"); // a = 7

方程 parseInt() 还可以设置转换数字的进制：

1

var a = parseInt("11", 2);// a =3

Use the Conditional (Ternary) Operator

条件运算符：

1
2
3
4
5
6
7
8
9
10
11
12

function findGreater(a, b) {
  if(a > b) {
    return "a is greater";
  }
  else {
    return "b is greater";
  }
}

function findGreater(a, b) {
  return a > b ? "a is greater" : "b is greater";
}

多个条件运算符：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

function findGreaterOrEqual(a, b) {
  if (a === b) {
    return "a and b are equal";
  }
  else if (a > b) {
    return "a is greater";
  }
  else {
    return "b is greater";
  }
}

function findGreaterOrEqual(a, b) {
  return (a === b) ? "a and b are equal" 
    : (a > b) ? "a is greater" 
    : "b is greater";
}

Use Recursion to Create a Countdown

使用递归来创造一个递减数列：

1
2
3
4
5
6
7
8
9
10

function countup(n) {
  if (n < 1) {
    return [];
  } else {
    const countArray = countup(n - 1);
    countArray.push(n);
    return countArray;
  }
}
console.log(countup(5)); // [ 1, 2, 3, 4, 5 ]

Use Recursion to Create a Range of Numbers

使用递归来创造某一范围内的整数数列：

1
2
3
4
5

function rangeOfNumbers(startNum, endNum) {
  return startNum === endNum
    ? [startNum]
    : rangeOfNumbers(startNum, endNum - 1).concat(endNum);
}

9 Python计算生态概览

9.1 从数据处理到人工智能

• 数据表示→数据清洗→数据统计→数据可视化→数据挖掘→人工智能

• 数据表示：采用合适方式用程序表达数据

• 数据清理：数据归一化、数据转换、异常值处理

• 数据统计：数据的概要理解，数量、分布、中位数等

• 数据可视化：直观展现数据内涵的方式

• 数据挖掘：从数据分析获得知识，产生数据外的价值

• 人工智能：数据、语言、图像、视觉等方面深度分析与决策

• Python库之数据分析：

  • Numpy：表达N维数组的最基础库

    

  • Pandas：Python数据分析高层次应用库

    • Series = 索引 + 一维数据
    • DataFrame = 行列索引 + 二维数据

  • SciPy：数学、科学和工程计算功能库

    • 提供了一批数学算法及工程数据运算工能

    • 类似Matlab，可用于如傅立叶变换、信号处理等应用

      

  • Matplotlib：高质量的二维数据可视化功能库

    

  • Seaborn：统计类数据可视化功能库

    • 提供了一批高层次的统计类数据可视化展示效果

    • 主要展示数据间分布、分类和线性关系等内容

      

  • Mayavi：三维科学数据可视化功能库

    

• Python库之文本处理

  • PyPDF2：用来处理pdf文件的工具集

    • 提供了一批处理PDF文件的计算功能

    • PDF文件的合并：

      1 2 3 4 5 6 7 8

      from PyPDF2 import PdfFileReader,PdfFileMerger merger = PdfFileMerger() input1 = open('document1.pdf','rb') input2 = open('document2.pdf','rb') merger.append(fileobj = input1, pages = (0,3)) merger.merge(position = 2,fileobj = input2, pages = (0,1)) output = open('document-out.pdf','wb') merger.write(output)

  • NLTK：自然语言文本处理第三方库

    • 提供了一批简单易用的自然语言文本处理功能

    • 支持语言文本分类、标记、语法句法、语义分析

      1 2 3

      from nltk.corpus import treebank t = treebank.parsed_sents('wsj_0001.mrg')[0] t.draw()

      

  • Python-docx：创建或更新Microsoft Word文件的第三方库

  • Python库之机器学习：

    • Scikit-learn：机器学习方法工具集
      • 提供一批统一化的机器学习方法功能接口
      • 提供聚类、分类、回归、强化学习等计算功能
    • TensorFlow：谷歌公司推动的开源机器学习框架
      • 将数据流图作为基础，图节点代表运算，边代表张量
    • MXNet：基于神经网络的深度学习计算框架
      • 提供可拓展的神经网络深度学习计算功能
      • 可用于自动驾驶、机器翻译、语音识别等众多领域

9.2 实例15：霍兰德人格分析雷达图

• 霍兰德人格分析

  • 人格兴趣与职业之间应有一种内在的对应关系

  • 人格分析：研究型、艺术型、社会型、企业型、传统型、现实型

  • 职业：工程师、实验员、艺术家、推销员、记事员、社会工作者

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

    #HollandRadarDraw import numpy as np import matplotlib.pyplot as plt import matplotlib matplotlib.rcParams['font.family']='SimHei' radar_labels = np.array(['研究型(I)','艺术型(A)','社会型(S)',\ '企业型(E)','常规型(C)','现实型(R)']) #雷达标签 nAttr = 6 data = np.array([[0.40, 0.32, 0.35, 0.30, 0.30, 0.88], [0.85, 0.35, 0.30, 0.40, 0.40, 0.30], [0.43, 0.89, 0.30, 0.28, 0.22, 0.30], [0.30, 0.25, 0.48, 0.85, 0.45, 0.40], [0.20, 0.38, 0.87, 0.45, 0.32, 0.28], [0.34, 0.31, 0.38, 0.40, 0.92, 0.28]]) #数据值 data_labels = ('艺术家', '实验员', '工程师', '推销员', '社会工作者','记事员') angles = np.linspace(0, 2*np.pi, nAttr, endpoint=False) data = np.concatenate((data, [data[0]])) angles = np.concatenate((angles, [angles[0]])) fig = plt.figure(facecolor="white") plt.subplot(111, polar=True) plt.plot(angles,data,'o-', linewidth=1, alpha=0.2) plt.fill(angles,data, alpha=0.25) plt.thetagrids(angles*180/np.pi, radar_labels,frac = 1.2) plt.figtext(0.52, 0.95, '霍兰德人格分析', ha='center', size=20) legend = plt.legend(data_labels, loc=(0.94, 0.80), labelspacing=0.1) plt.setp(legend.get_texts(), fontsize='large') plt.grid(True) plt.savefig('holland_radar.jpg') plt.show()

9.3 从Web解析到网络空间

• Python库之网络爬虫
  • Request：最友好的网络爬虫功能库
    • 提供了简单易用的类HTTP协议网络爬虫功能
    • 支持连接池、SSL、Cookies、HTTP(s)代理等
  • Scrapy：优秀的网络爬虫框架
    • 提供了构建网络爬虫系统的框架功能，功能半成品
    • 支持批量和定时网页爬取、听过数据处理流程等
  • pyspider：强大的Web页面爬取系统
    • 提供了完整的网页爬取系统构建功能
    • 支持数据库后端、消息队列、优先级、分布式架构等
  • Beautiful Soup：HTML和XML的解析库
  • Re：正则表达式解析和处理功能库
    • 提供了定义和解析正则表达式的一批通用功能
    • 可用于各类场景，包括定点的Web信息提取
  • Python-Goose：提取文章类型Web页面的功能库
    • 提供了对Web页面中文章信息、视频等元数据的提取功能
    • 针对特定类型Web页面，应用覆盖面较广
• Python库之Web网站开发
  • Django：最流行的Web应用框架
    • 提供了构件Web系统的基本应用框架
    • MTV模式：模型、模版、视图
  • Pyramid：规模适中的Web应用框架
    • 提供了简单方便构件Web系统的应用框架
    • 不大不小，规模适中，适合快速构建并适度扩展类应用
  • Flask：Web应用开发微框架
    • 提供了最简单构建Web系统的应用框架
    • 简单、规模小、快捷
  • WeRoBot：微信公众号开发框架
    • 提供了解析微信服务器消息及反馈消息的功能
    • 建立微信机器人的重要技术手段
  • aip：百度AI开放平台接口
    • 提供了访问百度AI服务的Python功能接口
    • 语音、人脸、OCR、NLP、知识图谱、图像搜索等领域
  • MyQR：二维码生成第三方库
    • 提供了生成二维码的系列功能
    • 基本二维码、艺术二维码和动态二维码

9.4 从人机交互到艺术设计

• Python库之图形用户界面
  • PyQt5：Qt开发框架的Python接口
    • 提供了创建Qt5程序的Python API接口
    • Qt是非常成熟的跨平台桌面应用开发系统，完备GUI
  • wxPython：跨平台GUI开发框架
    • 提供了专用于Python的跨平台GUI开发框架
    • 理解数据类型与索引的关系，操作索引即操作数据
  • PyGObject：使用GTK+开发GUI的功能库
• Python库之游戏开发
  • PyGame：简单的游戏开发功能库
  • Panda3D：开源、跨平台的3D渲染和游戏开发库
  • cocos2d：构建2D游戏和图形界面交互式应用的框架
• Python库之虚拟现实
  • VR Zero：在树莓派上开发VR应用的Python库
  • pyovr：Oculus Rift的开发接口
  • Vizard：基于Python的通用VR开发引擎
• Python库之图形艺术：
  • Quadas：迭代的艺术
    • 对图像进行四分迭代，形成像素风
  • ascii_art：ASCII艺术库
    • 将普通图片转为ASCII艺术风格
  • turtle：海龟绘图体系

9.5 实例16：玫瑰花绘制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

#RoseDraw.py
import turtle as t
# 定义一个曲线绘制函数
def DegreeCurve(n, r, d=1):
    for i in range(n):
        t.left(d)
        t.circle(r, abs(d))
# 初始位置设定
s = 0.2 # size
t.setup(450*5*s, 750*5*s)
t.pencolor("black")
t.fillcolor("red")
t.speed(100)
t.penup()
t.goto(0, 900*s)
t.pendown()
# 绘制花朵形状
t.begin_fill()
t.circle(200*s,30)
DegreeCurve(60, 50*s)
t.circle(200*s,30)
DegreeCurve(4, 100*s)
t.circle(200*s,50)
DegreeCurve(50, 50*s)
t.circle(350*s,65)
DegreeCurve(40, 70*s)
t.circle(150*s,50)
DegreeCurve(20, 50*s, -1)
t.circle(400*s,60)
DegreeCurve(18, 50*s)
t.fd(250*s)
t.right(150)
t.circle(-500*s,12)
t.left(140)
t.circle(550*s,110)
t.left(27)
t.circle(650*s,100)
t.left(130)
t.circle(-300*s,20)
t.right(123)
t.circle(220*s,57)
t.end_fill()
# 绘制花枝形状
t.left(120)
t.fd(280*s)
t.left(115)
t.circle(300*s,33)
t.left(180)
t.circle(-300*s,33)
DegreeCurve(70, 225*s, -1)
t.circle(350*s,104)
t.left(90)
t.circle(200*s,105)
t.circle(-500*s,63)
t.penup()
t.goto(170*s,-30*s)
t.pendown()
t.left(160)
DegreeCurve(20, 2500*s)
DegreeCurve(220, 250*s, -1)
# 绘制一个绿色叶子
t.fillcolor('green')
t.penup()
t.goto(670*s,-180*s)
t.pendown()
t.right(140)
t.begin_fill()
t.circle(300*s,120)
t.left(60)
t.circle(300*s,120)
t.end_fill()
t.penup()
t.goto(180*s,-550*s)
t.pendown()
t.right(85)
t.circle(600*s,40)
# 绘制另一个绿色叶子
t.penup()
t.goto(-150*s,-1000*s)
t.pendown()
t.begin_fill()
t.rt(120)
t.circle(300*s,115)
t.left(75)
t.circle(300*s,100)
t.end_fill()
t.penup()
t.goto(430*s,-1070*s)
t.pendown()
t.right(30)
t.circle(-600*s,35)
t.done()

8 程序设计方法

8.1 实例13：体育竞技分析

• 输入：球员的水平，输出：可预测的比赛成绩
• 自顶向下和自底向上：
  • 自顶向下（设计）：
    • 将一个总问题表达为若干个小问题组成的形式
    • 使用同样方法进一步分解小问题
    • 直至，小问题可以用计算机简单明了的解决
  • 自底向上（执行）：
    • 分单元测试，逐步组装
    • 按照自顶向下相反的路径操作
    • 直至，系统各部分以紫装的思路都经过测试和验证

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

#MatchAnalysis.py
from random import random
def printIntro():
    print("这个程序模拟两个选手A和B的某种竞技比赛")
    print("程序运行需要A和B的能力值（以0到1之间的小数表示）")
def getInputs():
    a = eval(input("请输入选手A的能力值(0-1): "))
    b = eval(input("请输入选手B的能力值(0-1): "))
    n = eval(input("模拟比赛的场次: "))
    return a, b, n
def simNGames(n, probA, probB):
    winsA, winsB = 0, 0
    for i in range(n):
        scoreA, scoreB = simOneGame(probA, probB)
        if scoreA > scoreB:
            winsA += 1
        else:
            winsB += 1
    return winsA, winsB
def gameOver(a,b):
    return a==15 or b==15
def simOneGame(probA, probB):
    scoreA, scoreB = 0, 0
    serving = "A"
    while not gameOver(scoreA, scoreB):
        if serving == "A":
            if random() < probA:
                scoreA += 1
            else:
                serving="B"
        else:
            if random() < probB:
                scoreB += 1
            else:
                serving="A"
    return scoreA, scoreB
def printSummary(winsA, winsB):
    n = winsA + winsB
    print("竞技分析开始，共模拟{}场比赛".format(n))
    print("选手A获胜{}场比赛，占比{:0.1%}".format(winsA, winsA/n))
    print("选手B获胜{}场比赛，占比{:0.1%}".format(winsB, winsB/n))
def main():
    printIntro()
    probA, probB, n = getInputs()
    winsA, winsB = simNGames(n, probA, probB)
    printSummary(winsA, winsB)
main()

8.2 Python程序设计思维

• 计算生态与Python语言：
  • 计算思维：抽象问题的计算过程，利用计算机自动化求解
• 计算生态与Python语言：
  • 以开源项目为代表的大量第三方库
  • 库之间相互关联，依存发展
• 用户体验与软件产品：
  • 提高用户体验的方法：进度展示、异常处理、打印输出、日志文件、帮助信息
• 基本的程序设计模式：
  • 从IPO开始：
  • 自顶向下设计
  • 模块化设计
  • 配置化设计
  • 从应用需求到软件产品
    • 产品定义
    • 系统架构
    • 设计与实现
    • 用户体验

8.3 Python第三方库安装

• 常用pip命令
  

8.4 模块7：OS库的使用

• os.path子库以path为入口，用于操作和处理文件路径
• 路径操作：

• 进程管理：

  1 2 3 4

  import os os.system(command) os.system('C:\\Windows\\System32\\Calc.exe')

• 环境参数：

8.5 实例14：第三方库安装脚本

1
2
3
4
5
6
7
8
9
10
11
12

#BatchInstall.py
import os
libs = {"numpy","matplotlib","pillow","sklearn","requests",\
        "jieba","beautifulsoup4","wheel","networkx","sympy",\
        "pyinstaller","django","flask","werobot","pyqt5",\
        "pandas","pyopengl","pypdf2","docopt","pygame"}
try:
    for lib in libs:
        os.system("pip install "+lib)
    print("Successful")        
except:
    print("Failed Somehow")

8.Practice

• 英文字符的鲁棒输入：输入字符串，打印输出其中的英文字母

1
2
3
4
5
6
7

s = input()
d = []
for i in range(26):
    d.append(chr(ord('a')+i))
for c in s:
    if c in d:
        print(c,end='')

• 数字的鲁棒输入：获得用户输入的一个数字，可能是浮点数或复数，如果是整数仅接收十进制形式，且只能是数字。对输入数字进行平方运算，输出结果。

1
2
3
4
5
6

s = input()
try:
    if complex(s) == complex(eval(s)):
        print(eval(s)**2)
except:
    print("输入有误")

7 文件和数据格式化

7.1 文件的类型

• 文件时存储在辅助存储器上的数据序列
• 文件展现形态：文本文件和二进制文件
• 文本形式打开文件：

1
2
3

tf = open('f.txt','rt')
print(tf.readline())
tf.close()

• 二进制形式打开文件：

1
2
3

bf = open('f.txt','rb')
print(bf.readline())
bf.close()

• 文件的打开和关闭：

  • 文件打开： = open (,)

  • 文件路径：用斜杠替代反斜杠，相对路径”./PYE/f.txt”

  • 文件打开模式：

    

  • 文件关闭：.close( )

• 文件内容的读取：

• 遍历全文本：

1
2
3
4
5

fname = input()
fo = open(fname,'r')
txt = fo.read()
#对全文txt进行处理
fo.close()

当文件较大时，读取会耗费大量资源

1
2
3
4
5
6

fname = input()
fo = open(fname,'r')
txt = fo.read()
while txt!="":
txt = fo.read(2)
fo.close()

逐行遍历：

1
2
3
4
5
6
7
8
9
10
11
12
13

# Solution 1
fname = input()
fo = open(fname,'r')
for line in fo.readlines():
print(line)
fo.close()

# Solution 2
fname = input()
fo = open(fname,'r')
for line in fo:
print(line)
fo.close()

• 数据的文件写入：

7.2 实例11：自动轨迹绘制

根据脚本来绘制图形

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#AutoTraceDraw.py
import turtle as t
t.title('自动轨迹绘制')
t.setup(800, 600, 0, 0)
t.pencolor("red")
t.pensize(5)
#数据读取
datals = []
f = open("data.txt")
for line in f:
    line = line.replace("\n","")
    datals.append(list(map(eval, line.split(","))))
f.close()
#自动绘制
for i in range(len(datals)):
    t.pencolor(datals[i][3],datals[i][4],datals[i][5])
    t.fd(datals[i][0])
    if datals[i][1]:
        t.rt(datals[i][2])
    else:
        t.lt(datals[i][2])

map(, list var): 对列表中每一个元素执行map函数里第一个参数对应的函数操作

7.3 一维数据的格式化和处理

• 一维数据：由对等关系的有序或无序数据构成。
• 二维数据：由多个一维数据构成，是一维数据的组合形式
• 多维数据：由一维或二维数据构成的一种扩展
• 高维数据：仅利用最基本的二元关系展示数据间的复杂结构（键值对）
• 一位数据的表示：
  • 如果数据间是无序的：使用集合类型
  • 有序的：列表类型
• 一维数据的存储：
  • 把数据之间使用空格分隔，缺点：数据中不能存在空格
  • 存储方式二：逗号分隔
  • 存储方式三：其它方式（其它特殊符号）
• 一维数据的处理：存储<->表示

读取数据

1
2
3
4
5
6
7
8

txt = open(fname).read()
ls = txt.split()
f.close()

# 特殊分隔符
txt = open(fname).read()
ls = txt.split('$')
f.close()

写入数据：

1
2
3
4

ls = ['China', 'US', 'Japan']
f = open(fname,'w')
f.write(' ',joint(ls))
f.close()

7.4 二维数据的格式化

• 二维数据的表示：采用二维列表表达格式
• 二维数据的读取：两层for循环来遍历数据
• CSV数据存储格式
  • 国际通用的一二维数据存储格式，一般.csv扩展名
  • 每行一个一维数据，采用逗号分隔，无空行
  • Excel和一般编辑软件都可以读入或者另存为csv文件
• CSV存储约定：
  • 如果某个元素缺失，逗号仍要保留
  • 二维数据的表头可以作为数据存储，也可以另行存储
  • 逗号为英文半角符号，逗号与数据之间无额外空格
  • 数据中包含逗号，使用在数据两侧增加引号等方法，或者增加转意符
• 常规的索引习惯：ls[row][column]，先行后列
• 二维数据的读写

1
2
3
4
5
6
7
8
9
10
11
12

fo = open(fname)
ls = []
for line in fo:
line = line.replace('\n','')
ls.append(ls.split(','))
fo.close()

ls = [[],[],[]]
f = open(fname,'w')
for item in ls:
fwrite(','.join(item)+'\n')
f.close()

7.5 模块6：wordcloud库

• wordcloud库是优秀的词云展示第三方库
• w = wordvloud.WordCloud()
• 词云的形状尺寸颜色都可以自定
• wordcloud库常规方法

• 配置对象参数：

7.6 实例12：政府工作报告词云

矩形词云：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#GovRptWordCloudv1.py
import jieba
import wordcloud
f = open("新时代中国特色社会主义.txt", "r", encoding="utf-8")
 
t = f.read()
f.close()
ls = jieba.lcut(t)
 
txt = " ".join(ls)
w = wordcloud.WordCloud( \
    width = 1000, height = 700,\
    background_color = "white",
    font_path = "msyh.ttc"    
    )
w.generate(txt)
w.to_file("grwordcloud.png")

不规则词云

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#GovRptWordCloudv2.py
import jieba
import wordcloud
from scipy.misc import imread
mask = imread("chinamap.jpg")
excludes = { }
f = open("新时代中国特色社会主义.txt", "r", encoding="utf-8")
t = f.read()
f.close()
ls = jieba.lcut(t)
txt = " ".join(ls)
w = wordcloud.WordCloud(\
    width = 1000, height = 700,\
    background_color = "white",
    font_path = "msyh.ttc", mask = mask
    )
w.generate(txt)
w.to_file("grwordcloudm.png")

7.Practice

• 文件行数：打印输出附件文件的有效行数，注意：空行不计算为有效行数。

1
2
3
4
5
6
7
8

f = open('latex.log','r',encoding='UTF-8')
count = 0
for line in f.readlines():
    if line == '\n':
        continue
    else:
        count += 1
print("共{}行".format(count))

• 文件字符分布：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

fname = 'latex.log'
fo = open(fname,'r',encoding='UTF-8')

d = {}
# 给每个小写字母添加一个键，防止有个数为0的字母
for i in range(26):
    d[chr(ord('a')+i)] = 0
wordcount = 0
for line in fo.readlines():
    for char in line:
        d[char] = d.get(char,0)+1
        wordcount += 1 #统计字符数
print('共{}字符'.format(wordcount),end='')

for i in range(26):
    if d[chr(ord('a')+i)]!=0:
        print(f",{chr(ord('a')+i)}:{d[chr(ord('a')+i)]}",end='')

• 文件独特行数：统计附件文件中与其他任何其他行都不同的行的数量，即独特行的数量。

1
2
3
4
5
6
7
8

fname = 'latex.log'
fo = open(fname,'r',encoding='UTF-8')
ls = fo.readlines()
s =set(ls)
for i in s:
    ls.remove(i)
t = set(ls)
print("共{}独特行".format(len(s)-len(t)))

• CSV格式列转换：附件是一个CSV文件，请将每行按照列逆序排列后输出，不改变各元素格式（如周围空格布局等）。

1
2
3
4
5
6
7
8

fname = 'data.csv'
fo = open(fname,'r')
for line in fo:
    line = line.strip('\n')
    ls = line.split(',')
    ls = ls[::-1]
    print(",".join(ls))
fo.close()

• CSV格式数据清洗：

附件是一个CSV文件，其中每个数据前后存在空格，请对其进行清洗，要求如下：‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬

（1）去掉每个数据前后空格，即数据之间仅用逗号(,)分割；‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬

（2）清洗后打印输出。

1
2
3
4
5

f = open("data.csv")
s = f.read()
s = s.replace(" ","")
print(s)
f.close()

6 组合数据类型

6.1 集合类型及操作

• 集合是多个元素的无序组合：
  • 几何元素之间无序，每个元素唯一，不存在相同元素
  • 集合元素不可更改，不能是可变数据类型
• 建立集合用 { } 或 set(), 空集合必须 set()

1
2

A = {"Python",123,("Py",123)}
B = set('pypy123') #{'1','2','3','p','y'}

• 集合操作符：

S ≤ T 或 S < T，返回 True/False 关系操作符

• 集合处理方法：

• 集合类型应用场景：
  • 数据去重：set( ) 和 list( )

6.2 序列类型及操作

• 序列类型的定义：序列是具有先后关系的一族元素
  • 序列是一维元素向量，元素类型可以不同
  • 元素间由序号引导
• 序列类型：字符串类型、元组类型、列表类型
• 序列类型及操作：正向递增序号、反向递减序号
• 序列类型通用操作符：

• 元组类型及操作：
  • 元组一旦被创建，不能更改
  • 元组用()或tuple()创建，元素间用逗号分隔
• 列表类型及操作：
  • 列表是一种序列类型，创建后可以随意修改
  • 使用[]或list()创建，元素间用逗号，分隔
  • 列表中各元素类型可以不同，无长度限制
  • 列表直接赋值时，只是将新的指针指向原有列表
• 列表类型操作方法：

• 序列类型应用场景：
  • 元素遍历
  • 通过元组类型进行数据保护

6.3 实例9：基本统计值计算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#CalStatisticsV1.py
def getNum():       #获取用户不定长度的输入
    nums = []
    iNumStr = input("请输入数字(回车退出): ")
    while iNumStr != "":
        nums.append(eval(iNumStr))
        iNumStr = input("请输入数字(回车退出): ")
    return nums
 
def mean(numbers):  #计算平均值
    s = 0.0
    for num in numbers:
        s = s + num
    return s / len(numbers)
 
def dev(numbers, mean): #计算方差
    sdev = 0.0
    for num in numbers:
        sdev = sdev + (num - mean)**2
    return pow(sdev / (len(numbers)-1), 0.5)
 
def median(numbers):    #计算中位数
    sorted(numbers)
    size = len(numbers)
    if size % 2 == 0:
        med = (numbers[size//2-1] + numbers[size//2])/2
    else:
        med = numbers[size//2]
    return med
 
n =  getNum() #主体函数
m =  mean(n)
print("平均值:{},方差:{:.2},中位数:{}.".format(m, dev(n,m),median(n)))

6.4 字典类型及操作

• 字典类型的定义：
  • 映射：映射是一种键（索引）和值（数据）的对应
  • 字典类型通过键值对建立索引
  • 采用 { } 或 dict()创建，键值对用: 来表示
  • 字典索引 [ ]
• 字典类型操作函数：

• 字典类型应用场景
  • 映射的表达：统计数据出现次数

6.5 模块5：jieba库

• jieba是优秀的中文分词第三方库
• 精确模式：把文本精确分开，不存在冗余单词
• 全模式：把文本中所有可能的词语都扫描出来，有冗余
• jieba库常用函数：

6.6 实例10：文本词频统计

• 《哈姆雷特》词频统计：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#CalHamletV1.py
def getText():
    txt = open("hamlet.txt", "r").read()
    txt = txt.lower()
    for ch in '!"#$%&()*+,-./:;<=>?@[\\]^_‘{|}~':
        txt = txt.replace(ch, " ")   #将文本中特殊字符替换为空格
    return txt
 
hamletTxt = getText()
words  = hamletTxt.split()
counts = {}
for word in words:           
    counts[word] = counts.get(word,0) + 1
items = list(counts.items())
items.sort(key=lambda x:x[1], reverse=True) 
for i in range(10):
    word, count = items[i]
    print ("{0:<10}{1:>5}".format(word, count))

• 三国演义出场人物统计：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#CalThreeKingdomsV2.py
import jieba
excludes = {"将军","却说","荆州","二人","不可","不能","如此"}
txt = open("threekingdoms.txt", "r", encoding='utf-8').read()
words  = jieba.lcut(txt)
counts = {}
for word in words:
    if len(word) == 1:
        continue
    elif word == "诸葛亮" or word == "孔明曰":
        rword = "孔明"
    elif word == "关公" or word == "云长":
        rword = "关羽"
    elif word == "玄德" or word == "玄德曰":
        rword = "刘备"
    elif word == "孟德" or word == "丞相":
        rword = "曹操"
    else:
        rword = word
    counts[rword] = counts.get(rword,0) + 1
for word in excludes:
    del counts[word]
items = list(counts.items())
items.sort(key=lambda x:x[1], reverse=True) 
for i in range(10):
    word, count = items[i]
    print ("{0:<10}{1:>5}".format(word, count))

6.Practice

• 人名独特性统计：统计字符串中共有多少个独特的人名

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

s = '''双儿 洪七公 赵敏 赵敏 逍遥子 鳌拜 殷天正 金轮法王 乔峰 杨过 洪七公 郭靖 
       杨逍 鳌拜 殷天正 段誉 杨逍 慕容复 阿紫 慕容复 郭芙 乔峰 令狐冲 郭芙 
       金轮法王 小龙女 杨过 慕容复 梅超风 李莫愁 洪七公 张无忌 梅超风 杨逍 
       鳌拜 岳不群 黄药师 黄蓉 段誉 金轮法王 忽必烈 忽必烈 张三丰 乔峰 乔峰 
       阿紫 乔峰 金轮法王 袁冠南 张无忌 郭襄 黄蓉 李莫愁 赵敏 赵敏 郭芙 张三丰 
       乔峰 赵敏 梅超风 双儿 鳌拜 陈家洛 袁冠南 郭芙 郭芙 杨逍 赵敏 金轮法王 
       忽必烈 慕容复 张三丰 杨逍 令狐冲 黄药师 袁冠南 杨逍 完颜洪烈 殷天正 
       李莫愁 阿紫 逍遥子 乔峰 逍遥子 完颜洪烈 郭芙 杨逍 张无忌 杨过 慕容复 
       逍遥子 虚竹 双儿 乔峰 郭芙 黄蓉 李莫愁 陈家洛 杨过 忽必烈 鳌拜 王语嫣 
       洪七公 韦小宝 阿朱 梅超风 段誉 岳灵珊 完颜洪烈 乔峰 段誉 杨过 杨过 慕容复 
       黄蓉 杨过 阿紫 杨逍 张三丰 张三丰 赵敏 张三丰 杨逍 黄蓉 金轮法王 郭襄 
       张三丰 令狐冲 郭芙 韦小宝 黄药师 阿紫 韦小宝 金轮法王 杨逍 令狐冲 阿紫 
       洪七公 袁冠南 双儿 郭靖 鳌拜 谢逊 阿紫 郭襄 梅超风 张无忌 段誉 忽必烈 
       完颜洪烈 双儿 逍遥子 谢逊 完颜洪烈 殷天正 金轮法王 张三丰 双儿 郭襄 阿朱 
       郭襄 双儿 李莫愁 郭襄 忽必烈 金轮法王 张无忌 鳌拜 忽必烈 郭襄 令狐冲 
       谢逊 梅超风 殷天正 段誉 袁冠南 张三丰 王语嫣 阿紫 谢逊 杨过 郭靖 黄蓉 
       双儿 灭绝师太 段誉 张无忌 陈家洛 黄蓉 鳌拜 黄药师 逍遥子 忽必烈 赵敏 
       逍遥子 完颜洪烈 金轮法王 双儿 鳌拜 洪七公 郭芙 郭襄'''
ls = set(s.split(sep=" "))
ls.discard('')
ls.discard('\n')
print(len(ls))

• 字典翻转输出：读入一个字典类型的字符串，反转其中的键值对输出

1
2
3
4
5
6
7
8
9

s = input()
try:
    d = eval(s)
    e = {}
    for k in d:
        e[d[k]] = k
    print(e)
except:
    print("输入错误")

• 《沉默的羔羊》之最多单词

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

import jieba
f = open("沉默的羔羊.txt")
ls = jieba.lcut(f.read())
d = {}
for w in ls:
    d[w] = d.get(w,0)+1
maxc = 0
maxw = ""
for k in d:
    if d[k] > maxc and len(k) > 2:
        maxc = d[k]
        maxw = k
    if d[k] == maxc and len(k) > 2 and k > maxw:
        maxw = k
print(maxw)
f.close()

• 数字不同数之和：获得用户输入的一个整数N，输出N中出现不同数字的和

  输入：1231233213

  输出：6

1
2
3
4
5
6

s = input()
ls = []
for num in s:
    ls.append(eval(num))
arr = set(ls)
print(sum(arr))

• 人名最多数统计：输出字符串中出现次数最多的人名

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

s = '''双儿 洪七公 赵敏 赵敏 逍遥子 鳌拜 殷天正 金轮法王 乔峰 杨过 洪七公 郭靖 
       杨逍 鳌拜 殷天正 段誉 杨逍 慕容复 阿紫 慕容复 郭芙 乔峰 令狐冲 郭芙 
       金轮法王 小龙女 杨过 慕容复 梅超风 李莫愁 洪七公 张无忌 梅超风 杨逍 
       鳌拜 岳不群 黄药师 黄蓉 段誉 金轮法王 忽必烈 忽必烈 张三丰 乔峰 乔峰 
       阿紫 乔峰 金轮法王 袁冠南 张无忌 郭襄 黄蓉 李莫愁 赵敏 赵敏 郭芙 张三丰 
       乔峰 赵敏 梅超风 双儿 鳌拜 陈家洛 袁冠南 郭芙 郭芙 杨逍 赵敏 金轮法王 
       忽必烈 慕容复 张三丰 赵敏 杨逍 令狐冲 黄药师 袁冠南 杨逍 完颜洪烈 殷天正 
       李莫愁 阿紫 逍遥子 乔峰 逍遥子 完颜洪烈 郭芙 杨逍 张无忌 杨过 慕容复 
       逍遥子 虚竹 双儿 乔峰 郭芙 黄蓉 李莫愁 陈家洛 杨过 忽必烈 鳌拜 王语嫣 
       洪七公 韦小宝 阿朱 梅超风 段誉 岳灵珊 完颜洪烈 乔峰 段誉 杨过 杨过 慕容复 
       黄蓉 杨过 阿紫 杨逍 张三丰 张三丰 赵敏 张三丰 杨逍 黄蓉 金轮法王 郭襄 
       张三丰 令狐冲 赵敏 郭芙 韦小宝 黄药师 阿紫 韦小宝 金轮法王 杨逍 令狐冲 阿紫 
       洪七公 袁冠南 双儿 郭靖 鳌拜 谢逊 阿紫 郭襄 梅超风 张无忌 段誉 忽必烈 
       完颜洪烈 双儿 逍遥子 谢逊 完颜洪烈 殷天正 金轮法王 张三丰 双儿 郭襄 阿朱 
       郭襄 双儿 李莫愁 郭襄 忽必烈 金轮法王 张无忌 鳌拜 忽必烈 郭襄 令狐冲 
       谢逊 梅超风 殷天正 段誉 袁冠南 张三丰 王语嫣 阿紫 谢逊 杨过 郭靖 黄蓉 
       双儿 灭绝师太 段誉 张无忌 陈家洛 黄蓉 鳌拜 黄药师 逍遥子 忽必烈 赵敏 
       逍遥子 完颜洪烈 金轮法王 双儿 鳌拜 洪七公 郭芙 郭襄 赵敏'''
ls = s.split(sep=" ")
d = {}
for name in ls:
    d[name] = d.get(name,0)+1
maxvalue = 0
maxname = ''
for key in d:
    if key == '\n' or key == '':
        continue
    elif d[key] > maxvalue:
        maxvalue = d[key]
        maxname = key
print(maxname)

5 函数和代码复用

5.1 函数的定义与使用

• 函数是一段代码的表示

• def <函数名>(<函数参数>)：

  <函数代码>

• 函数的调用：调用时要给出实际参数

• 可选参数：可选参数某些参数提供默认值，可选参数必须放在必选参数后面

  1 2 3 4 5 6

  def fact(n,m=1): s = 1 for i in range(1,n+1) s*=i s = s/m return s

• 可变参数的传递：函数定义时可以设计可变数量参数，即不确定参数总数量

  1 2 3 4 5 6 7

  def fact(n,*b) s = 1 for i in range(1,n+1) s *= i for item in b s *= b return s

• 位置对应，名字对应

  1	fact(m=5,n=10)

• 返回值：返回多个数据，元组类型：return s//m, n, m （元组类型）

• 在函数中使用全局变量：保留字global

• 局部变量为组合数据类型且未创建，等同于全局变量

  1 2 3 4 5 6

  ls = ['F','f'] def func(a)： ls.append(a) return func("c") print(ls)

• lambda 函数：是一种匿名函数，返回函数名

  • <函数名> = lambda <参数>:<表达式>

    1 2 3

    f = lambda x,y：x+y f(10,15) f = lambda: "lambda function"

5.2 实例7：七段数码管绘制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#SevenDigitsDrawV1.py
import turtle
def drawLine(draw):   #绘制单段数码管
    turtle.pendown() if draw else turtle.penup()
    turtle.fd(40)
    turtle.right(90)
def drawDigit(digit): #根据数字绘制七段数码管
    drawLine(True) if digit in [2,3,4,5,6,8,9] else drawLine(False)
    drawLine(True) if digit in [0,1,3,4,5,6,7,8,9] else drawLine(False)
    drawLine(True) if digit in [0,2,3,5,6,8,9] else drawLine(False)
    drawLine(True) if digit in [0,2,6,8] else drawLine(False)
    turtle.left(90)
    drawLine(True) if digit in [0,4,5,6,8,9] else drawLine(False)
    drawLine(True) if digit in [0,2,3,5,6,7,8,9] else drawLine(False)
    drawLine(True) if digit in [0,1,2,3,4,7,8,9] else drawLine(False)
    turtle.left(180)
    turtle.penup()
    turtle.fd(20) 
def drawDate(date):  #获得要输出的数字
    for i in date:
        drawDigit(eval(i))  #通过eval()函数将数字变为整数
def main():
    turtle.setup(800, 350, 200, 200)
    turtle.penup()
    turtle.fd(-300)
    turtle.pensize(5)
    drawDate('20181010')
    turtle.hideturtle()
    turtle.done()
main()