JS执行流程&变量提升 
一段代码的执行
1、一段js代码在执行过程中，需要先做变量提升，为什么要做变量提升呢？因为在代码执行之前需要先编译2、在编译阶段，变量和函数会被存放在变量环境中，变量的值会被设置为undefined
3、在执行阶段，js引擎会从变量环境中查找自定义的变量和函数
因此我们知道 js的执行机制是：先编译，后执行
分析每个步骤的详细内容
 一段代码 
怎样的一段代码，会在执行之前就进行编译，并创建执行上下文
执行全局代码时：在整个页面的生存周期内，只有一份
调用一个函数时：一般情况下，函数执行网，创建的执行上下文会被销毁
使用eval函数时
 编译阶段 -- 变量提升 
在了解变量提升之前，先说一下javascript中的声明和赋值
1、变量的声明和赋值：
var nyname = 'jingda'
这段代码你可以看成两段代码组成
var myname //声明部分
myname = 'jingda' //赋值部分
2、函数的声明和赋值
function foo(){
  console.log('foo')
}

var bar = function(){
  console.log('bar')
}
第一个函数foo是一个完整的函数声明，没有涉及到赋值操作；第二个函数先声明变量bar，再把下面这部分赋值给bar
function(){
  console.log('bar')
}
然后我们可以来说一下变量提升：
所谓变量提升，指的javascript代码执行过程中，javascript引擎把变量的声明部分和函数的声明部分提升到了代码开头的“行为”。
变量被提升后，会给变量设置默认值undefined
举个例子：
showName()
console.log(myname)
var myname = 'jingda'
function showName(){
  console.log('函数 showName 被执行')
}
我们可以看到函数showName()已经执行成功，但是console.log(myname)输出undefined此时我们的 myname 是在声明之前执行，于是它输出结果为undefined，
那如果它没有声明呢？可以看到当我们把声明变量的代码注释之后，没有返回undefined，而是报错了。从上面的例子可以得到下面三个结论：
使用了未声明的变量，那么js执行会报错
在一个变量定义之前使用它，不会报错，但是该变量的值为undefined，而不是之后会定义的值
在一个函数定义之前使用它，不会出错，函数能正确执行。
第一个结论很好理解，未声明报错。那第二，三个呢？让我们看看之前说过的所谓变量提升：javascript引擎把变量的声明部分和函数的声明部分提升到了代码开头的“行为”，同时会给变量设置默认值undefined
那么刚才的代码在变量提升之后就应该是这样的代码
//变量提升
var myname = undefined //变量声明
function showName(){    //函数声明
  console.log('函数 showName 被执行')
}

//可执行代码
showName()
console.log(myname)
 myname = 'jingda'
相信这样写你会更加明白可以在定义之前使用变量或者函数的原因：函数和变量在执行之前都提升到了代码的开头；
 文章总结： 
Javascrip的执行流程
1、编译阶段
存在变量提升：这里注意，实际上变量和函数声明在代码里的位置是不会改变的，而是在编译阶段被javascript引擎放入内存中。再拿刚才的例子
第一部分：变量提升部分的代码
var myname = undefined //变量声明
function showName(){    //函数声明
  console.log('函数 showName 被执行')
}
第二部分：执行部分的代码
showName()
console.log(myname)
 myname = 'jingda'
把javascript的执行过程细化可以看出：输入一段代码，编译之后，会生成两部分内容：执行上下文和可执行代码执行上下文是javascript执行一段代码时的运行环境
这样说明一下：执行上下文里面应该是这样的：在后面学习有关执行上下文的时候会再说明。
2、执行阶段
js引擎开始执行“可执行代码”，按照顺序一行行的执行。
‘一起学习吧’ 
- END -

在进行软件构造Lab3实验时，关于储存时间的变量类型Calendar的相关操作属实让我头疼了很久。在网上进行相关查找也是给了一知半解，经过在eclipse上的不断尝试和查看java的相关源码后，我将网上查到的一些关于Calendar变量的常用操作进行了总结。

一：首先我们需要了解Calendar变量：

与Date变量相比，`Date类是类，表示的是特定的，瞬间的，它能精确毫秒，表示的是日期。而Calendar是一种抽象类，相比Date它在操作日历的时候提供了一些方法来操作日历字段，表示的是日历。绝大多数情况下，date要实现的功能都可以通过calendar来实现的，可以简单的认为Calendar是Date的加强版。
二：Date和Calendar类的初始化及转换：

a、Date
  Date date = new Date();
    System.out.println("毫秒:"+date.getTime());//输入毫秒
 
    //时间转字符串
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    String time = sdf.format(date);
    System.out.println("时间转字符串:"+time);
 
    //利用字符串来转时间格式（记得抛出异常）
    String time02 = "2018-09-05";
    SimpleDateFormat  sdf2 = new SimpleDateFormat ("yyyy-MM-dd");
    Date date2 = sdf2.parse(time02);
    System.out.println("字符串转时间格式："+date2);

b、Calendar
 // 使用默认时区和语言环境获得一个日历
    Calendar cal = Calendar.getInstance();
    // 赋值时年月日时分秒常用的6个值，注意月份下标从0开始，所以取月份要+1
    System.out.println("年:" + cal.get(Calendar.YEAR));
    System.out.println("月:" + (cal.get(Calendar.MONTH) + 1));
    System.out.println("日:" + cal.get(Calendar.DAY_OF_MONTH));
    System.out.println("时:" + cal.get(Calendar.HOUR_OF_DAY));
    System.out.println("分:" + cal.get(Calendar.MINUTE));
    System.out.println("秒:" + cal.get(Calendar.SECOND));
 
    //手动设置某个日期
    Calendar cal02 = Calendar.getInstance();
    //注意，设置时间的时候月份的下标是在0开始的
    //设置时间不一定要这6个参数3个参数也是可以的
    cal02.set(2018,9,1,12,0,0);//二零一八年十月一号十二点
    System.out.println(cal02.getTime());

c、Date和Calendar互相转换
1、
Calendar转Date
Calendar cal = Calendar.getInstance();
Date date = cal.getTime();


Calendar cal = Calendar.getInstance();
Date date = cal.getTime();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
String s = simpleDateFormat.format(date);
System.out.println("时间为===="+s);

2、Date转Calendar
Date date2 = new Date();
Calendar cal2 = Calendar.getInstance();
cal2.setTime( date );


Date date2 = new Date();
Calendar cal2 = Calendar.getInstance();
cal2.setTime(date );
System.out.println(cal2.get(Calendar.YEAR) +"-"+(cal2.get(Calendar.MONTH)+1)+"-"+cal2.get(Calendar.DATE));

三：Calendar的相关操作：
  // 字符串转换日期格式 
    // DateFormat fmtDateTime = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
    // 接收传入参数 
    // String strDate = args[1]; 
    // 得到日期格式对象 
    // Date date = fmtDateTime.parse(strDate); 
   
    // 完整显示今天日期时间 
    String str = (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS")).format(new Date()); 
    System.out.println(str); 
   
    // 创建 Calendar 对象 
    Calendar calendar = Calendar.getInstance(); 
   
    try 
    { 
      // 对 calendar 设置时间的方法 
      // 设置传入的时间格式 
      SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-M-d H:m:s"); 
      // 指定一个日期 
      Date date = dateFormat.parse("2013-6-1 13:24:16"); 
      // 对 calendar 设置为 date 所定的日期 
      calendar.setTime(date); 
   
      // 按特定格式显示刚设置的时间 
      str = (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS")).format(calendar.getTime()); 
      System.out.println(str); 
    } 
    catch (ParseException e) 
    { 
      e.printStackTrace(); 
    } 
   
    // 或者另一種設置 calendar 方式 
    // 分別爲 year, month, date, hourOfDay, minute, second 
    calendar = Calendar.getInstance(); 
    calendar.set(2013, 1, 2, 17, 35, 44); 
    str = (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS")).format(calendar.getTime()); 
    System.out.println(str); 
   
    // Calendar 取得当前时间的方法 
    // 初始化 (重置) Calendar 对象 
    calendar = Calendar.getInstance(); 
    // 或者用 Date 来初始化 Calendar 对象 
    calendar.setTime(new Date()); 
   
    // setTime 类似上面一行 
    // Date date = new Date(); 
    // calendar.setTime(date); 
   
    str = (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS")).format(calendar.getTime()); 
    System.out.println(str); 
   
    // 显示年份 
    int year = calendar.get(Calendar.YEAR); 
    System.out.println("year is = " + String.valueOf(year)); 
   
    // 显示月份 (从0开始, 实际显示要加一) 
    int month = calendar.get(Calendar.MONTH); 
    System.out.println("nth is = " + (month + 1)); 
   
    // 本周几 
    int week = calendar.get(Calendar.DAY_OF_WEEK); 
    System.out.println("week is = " + week); 
   
    // 今年的第 N 天 
    int DAY_OF_YEAR = calendar.get(Calendar.DAY_OF_YEAR); 
    System.out.println("DAY_OF_YEAR is = " + DAY_OF_YEAR); 
   
    // 本月第 N 天 
    int DAY_OF_MONTH = calendar.get(Calendar.DAY_OF_MONTH); 
    System.out.println("DAY_OF_MONTH = " + String.valueOf(DAY_OF_MONTH)); 
   
    // 3小时以后 
    calendar.add(Calendar.HOUR_OF_DAY, 3); 
    int HOUR_OF_DAY = calendar.get(Calendar.HOUR_OF_DAY); 
    System.out.println("HOUR_OF_DAY + 3 = " + HOUR_OF_DAY); 
   
    // 当前分钟数 
    int MINUTE = calendar.get(Calendar.MINUTE); 
    System.out.println("MINUTE = " + MINUTE); 
   
    // 15 分钟以后 
    calendar.add(Calendar.MINUTE, 15); 
    MINUTE = calendar.get(Calendar.MINUTE); 
    System.out.println("MINUTE + 15 = " + MINUTE); 
   
    // 30分钟前 
    calendar.add(Calendar.MINUTE, -30); 
    MINUTE = calendar.get(Calendar.MINUTE); 
    System.out.println("MINUTE - 30 = " + MINUTE); 
   
    // 格式化显示 
    str = (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS")).format(calendar.getTime()); 
    System.out.println(str); 
   
    // 重置 Calendar 显示当前时间 
    calendar.setTime(new Date()); 
    str = (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SS")).format(calendar.getTime()); 
    System.out.println(str); 
   
    // 创建一个 Calendar 用于比较时间 
    Calendar calendarNew = Calendar.getInstance(); 
   
    // 设定为 5 小时以前，后者大，显示 -1 
    calendarNew.add(Calendar.HOUR, -5); 
    System.out.println("时间比较：" + calendarNew.compareTo(calendar)); 
   
    // 设定7小时以后，前者大，显示 1 
    calendarNew.add(Calendar.HOUR, +7); 
    System.out.println("时间比较：" + calendarNew.compareTo(calendar)); 
   
    // 退回 2 小时，时间相同，显示 0 
    calendarNew.add(Calendar.HOUR, -2); 
    System.out.println("时间比较：" + calendarNew.compareTo(calendar)); 
  
   // 得微秒级时间差 
   long val = calendarEnd.getTimeInMillis() - calendarBegin.getTimeInMillis(); 
  // 换算后得到天数 
   long day = val / (1000 * 60 * 60 * 24);
   //也可以对Calender变量进行两个getTime操作得到val差值再换算
   
   //对于Calendar大小的比较，直接调用Calendar的Compare方法进行比较，前者大于后者返回正数，相等为0，小于为负数
   


参考文章

文章目录
对变量的基本操作
如何查看变量类型?
如何将变量的类型强制转化？
变量基本运算符的优先级顺序
不同逻辑结构
分类讨论（分支）
连续做相同操作（循环）
特殊变量：字符串
如何用一个变量储存多行字符串？
如何取消print()的默认换行输出
如何输出'Hello,world!'类型的字符串
字符串的运算
如何把两个字符串拼起来
如何重复输出一个字符串
如何确定变量的地址是否相同？(一般什么情况下需要确认地址？)
如何确定一个字符串是否包含某个字符子串？（作业包括，文献查找？）
如何截取字符子串
如何遍历字符串
如何将其他形式的变量用字符串形式输出
能不能通过字符串的索引改变其中的字符内容？
容器（相当于一个类）：列表list
通过生成式创建列表
拼接、重复、成员运算、索引和切片以及比较运算（类似字符串）
如何在list里添加元素
如何删除指定元素或者删除指定位置元素
如何查找元素位置
如何计算某个元素在list里面的个数
如何对列表元素排序和反转
如何同时生成元素和元素下标的list
元组（tuple）
tuple与list的不同之处
如何创建tuple？
如何创建一元组
如何将元组的值分别给不同的变量？
元组的值分给不同变量，分配的变量的个数少于元组的值，应该怎么办？
元组和列表如何相互转换？
集合
与list、tuple的区别
如何构建集合
什么是hashable类型？
如何对集合求交集、并集、差集？
集合如何添加删除某个元素？
如何判断A集合是否为B集合的子集？
如何创建不可变集合？
字典
如何创建字典类型？
如何将两个列表并成一个字典？
如何根据关键字(key)遍历/修改字典？
函数
带默认值和不带默认值的函数变量需要怎么排放顺序？
不确定输入几个输入，如何定义函数自变量？
如何引用别的文件的函数？

对变量的基本操作
如何查看变量类型?

如何将变量的类型强制转化？

变量基本运算符的优先级顺序

不同逻辑结构
分类讨论（分支）
elif(即相当于C/C++里面的else if)
连续做相同操作（循环）
for num in range(1,10):

# python喜欢用左闭右开的结构，range相当于1-9

for _ in range(2):
#重复两次操作

特殊变量：字符串
如何用一个变量储存多行字符串？
s3 = '''
hello, 
world!
'''
print(s3, end='')

如何取消print()的默认换行输出
print(s3, end=’’)

print函数中的end=’‘表示输出后不换行，即将默认的结束符\n（换行符）更换为’’（空字符）。
如何输出’Hello,world!'类型的字符串
1、（使用转义符号\）
s1 = '\'hello, world!\''
print(s1)
#'hello,world'

2、在字符串前加小写r
# 字符串s1中\t是制表符，\n是换行符
s1 = '\time up \now'
print(s1)
# 字符串s2中没有转义字符，每个字符都是原始含义
s2 = r'\time up \now'
print(s2)
#	ime up 
#ow
#\time up \now

字符串的运算
如何把两个字符串拼起来
s1 = 'hello' + ' ' + 'world'
print(s1)    # hello world

如何重复输出一个字符串
1、for循环

2、*操作
s2 = '!' * 3
print(s2)    # !!!

如何确定变量的地址是否相同？(一般什么情况下需要确认地址？)
s1 = 'hello world'
s2 = 'hello world'
s3 = s2
# 比较字符串的内容
print(s1 == s2, s2 == s3)    # True True
# 比较字符串的内存地址
print(s1 is s2, s2 is s3)    # False True

如何确定一个字符串是否包含某个字符子串？（作业包括，文献查找？）
s1 = 'hello, world'
print('wo' in s1)    # True
s2 = 'goodbye'
print(s2 in s1)      # False

如何截取字符子串
s[a: b : s]

a:开始位置

b:结束位置

s:步长
如何遍历字符串
1、
s1 = 'hello'
for ch in s1:
    print(ch)

2、用索引
s1 = 'hello'
for index in range(len(s1)):
    print(s1[index])

如何将其他形式的变量用字符串形式输出
a = 321
b = 123
print(f'{a} * {b} = {a * b}')

能不能通过字符串的索引改变其中的字符内容？
注意：

字符串是不可变类型，所以不能通过索引运算修改字符串中的字符
s1 = 'fack'
s1[1] = 'u'

print(s1)
#TypeError: 'str' object does not support item assignment

容器（相当于一个类）：列表list
通过生成式创建列表
# 创建一个由1到9的数字构成的列表
items1 = [x for x in range(1, 10)]
print(items1)    # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 创建一个由'hello world'中除空格和元音字母外的字符构成的列表
items2 = [x for x in 'hello world' if x not in ' aeiou']
print(items2)    # ['h', 'l', 'l', 'w', 'r', 'l', 'd']

# 创建一个由个两个字符串中字符的笛卡尔积构成的列表
items3 = [x + y for x in 'ABC' for y in '12']
print(items3)    # ['A1', 'A2', 'B1', 'B2', 'C1', 'C2']

拼接、重复、成员运算、索引和切片以及比较运算（类似字符串）
和数组类似，不过list可以放入的变量类型不限于单个字符或者整数，什么都可以放，因此相当方便
items1 = [35, 12, 99, 68, 55, 87]
items2 = [45, 8, 29]

# 列表的拼接
items3 = items1 + items2
print(items3)    # [35, 12, 99, 68, 55, 87, 45, 8, 29]

# 列表的重复
items4 = ['hello'] * 3
print(items4)    # ['hello', 'hello', 'hello']

# 列表的成员运算
print(100 in items3)        # False
print('hello' in items4)    # True

# 获取列表的长度(元素个数)
size = len(items3)
print(size)                 # 9

# 列表的索引
print(items3[0], items3[-size])        # 35 35
items3[-1] = 100
print(items3[size - 1], items3[-1])    # 100 100

# 列表的切片
print(items3[:5])          # [35, 12, 99, 68, 55]
print(items3[4:])          # [55, 87, 45, 8, 100]
print(items3[-5:-7:-1])    # [55, 68]
print(items3[::-2])        # [100, 45, 55, 99, 35]

# 列表的比较运算
items5 = [1, 2, 3, 4]
items6 = list(range(1, 5))
# 两个列表比较相等性比的是对应索引位置上的元素是否相等
print(items5 == items6)    # True
items7 = [3, 2, 1]
# 两个列表比较大小比的是对应索引位置上的元素的大小
print(items5 <= items7)    # True

如何在list里添加元素
items = ['Python', 'Java', 'Go', 'Kotlin']

# 使用append方法在列表尾部添加元素
items.append('Swift')
print(items)    # ['Python', 'Java', 'Go', 'Kotlin', 'Swift']
# 使用insert方法在列表指定索引位置插入元素
items.insert(2, 'SQL')
print(items)    # ['Python', 'Java', 'SQL', 'Go', 'Kotlin', 'Swift']

如何删除指定元素或者删除指定位置元素
items = ['Python', 'Java', 'Go', 'Kotlin']
# 删除指定的元素
items.remove('Java')
print(items)    # ['Python', 'Go', 'Kotlin']
# 删除指定索引位置的元素
items.pop(0)
print(items)    # ['Go', 'Kotlin']
del items[1]
print(items)    # ['Go']

如何查找元素位置
items = ['Python', 'Java', 'Java', 'Go', 'Kotlin', 'Python']

# 查找元素的索引位置
print(items.index('Python'))       # 0
print(items.index('Python', 2))    # 5
# 注意：虽然列表中有'Java'，但是从索引为3这个位置开始后面是没有'Java'的
print(items.index('Java', 3))      # ValueError: 'Java' is not in list

如何计算某个元素在list里面的个数
items = ['Python', 'Java', 'Java', 'Go', 'Kotlin', 'Python']

# 查找元素出现的次数
print(items.count('Python'))    # 2
print(items.count('Go'))        # 1
print(items.count('Swfit'))     # 0

如何对列表元素排序和反转
items = ['Python', 'Java', 'Go', 'Kotlin', 'Python']

# 排序
items.sort()
print(items)    # ['Go', 'Java', 'Kotlin', 'Python', 'Python']
# 反转
items.reverse()
print(items)    # ['Python', 'Python', 'Kotlin', 'Java', 'Go']

如何同时生成元素和元素下标的list
enumerate（list）

注：python内置函数
元组（tuple）
tuple与list的不同之处
元组和列表的不同之处在于，元组是不可变类型（可以放一些不可变量）
如何创建tuple？
# 定义一个三元组
t1 = (30, 10, 55)
# 定义一个四元组
t2 = ('骆昊', 40, True, '四川成都')

如何创建一元组
# 不是元组
b = ('hello')
print(type(b))    # <class 'str'>
# 一元组
d = ('hello', )
print(type(d))    # <class 'tuple'>

如何将元组的值分别给不同的变量？
当我们把多个用逗号分隔的值赋给一个变量时，多个值会打包成一个元组类型；当我们把一个元组赋值给多个变量时，元组会解包成多个值然后分别赋给对应的变量
# 打包
a = 1, 10, 100
print(type(a), a)    # <class 'tuple'> (1, 10, 100)
# 解包
i, j, k = a
print(i, j, k)       # 1 10 100

注意：

解包语法对list也都成立
元组的值分给不同变量，分配的变量的个数少于元组的值，应该怎么办？
加*号（其实就是引用地址）
a = 1, 10, 100, 1000
i, j, *k = a
print(i, j, k)          # 1 10 [100, 1000]

元组和列表如何相互转换？
# 将元组转换成列表
info = ('骆昊', 175, True, '四川成都')
print(list(info))       # ['骆昊', 175, True, '四川成都']
# 将列表转换成元组
fruits = ['apple', 'banana', 'orange']
print(tuple(fruits))    # ('apple', 'banana', 'orange')

集合
与list、tuple的区别
无序性、互异性
如何构建集合
# 创建集合的字面量语法(重复元素不会出现在集合中)
set1 = {1, 2, 3, 3, 3, 2}
print(set1)         # {1, 2, 3}

# 创建集合的构造器语法
set2 = set('hello')
print(set2)         # {'h', 'l', 'o', 'e'}
# 将列表转换成集合(可以去掉列表中的重复元素)
set3 = set([1, 2, 3, 3, 2, 1])
print(set3)         # {1, 2, 3}

集合中的元素必须是hashable类型。
什么是hashable类型？
所谓hashable类型指的是能够计算出哈希码的数据类型，你可以暂时将哈希码理解为和变量对应的唯一的ID值。
通常不可变类型都是hashable类型，如整数、浮点、字符串、元组等，而可变类型都不是hashable类型，因为可变类型无法确定唯一的ID值，所以也就不能放到集合中。
集合本身也是可变类型，所以集合不能够作为集合中的元素，这一点请大家一定要注意。
如何对集合求交集、并集、差集？
set1 = {1, 2, 3, 4, 5, 6, 7}
set2 = {2, 4, 6, 8, 10}

# 交集
# 方法一: 使用 & 运算符
print(set1 & set2)        # {2, 4, 6}
# 方法二: 使用intersection方法
print(set1.intersection(set2))  # {2, 4, 6}

# 并集
# 方法一: 使用 | 运算符
print(set1 | set2)         # {1, 2, 3, 4, 5, 6, 7, 8, 10}
# 方法二: 使用union方法
print(set1.union(set2))    # {1, 2, 3, 4, 5, 6, 7, 8, 10}

# 差集
# 方法一: 使用 - 运算符
print(set1 - set2)              # {1, 3, 5, 7}
# 方法二: 使用difference方法
print(set1.difference(set2))    # {1, 3, 5, 7}

# 对称差
# 方法一: 使用 ^ 运算符（相同的去掉，不同的保留，A∪B-A∩B）
print(set1 ^ set2)                        # {1, 3, 5, 7, 8, 10}
# 方法二: 使用symmetric_difference方法
print(set1.symmetric_difference(set2))    # {1, 3, 5, 7, 8, 10}
# 方法三: 对称差相当于两个集合的并集减去交集
print((set1 | set2) - (set1 & set2))      # {1, 3, 5, 7, 8, 10}

集合如何添加删除某个元素？
# 创建一个空集合
set1 = set()
# 通过add方法添加元素
set1.add(33)
set1.add(55)
set1.update({1, 10, 100, 1000})
print(set1)    # {33, 1, 100, 55, 1000, 10}

# 通过discard方法删除指定元素
set1.discard(100)
set1.discard(99)
print(set1)    # {1, 10, 33, 55, 1000}
# 通过remove方法删除指定元素，建议先做成员运算再删除
# 否则元素如果不在集合中就会引发KeyError异常
if 10 in set1:
    set1.remove(10)
print(set1)    # {33, 1, 55, 1000}

如何判断A集合是否为B集合的子集？
set1 = {1, 3, 5}
set2 = {1, 2, 3, 4, 5}
set3 = set2
# <运算符表示真子集，<=运算符表示子集
print(set1 < set2, set1 <= set2)    # True True
print(set2 < set3, set2 <= set3)    # False True
# 通过issubset方法也能进行子集判断
print(set1.issubset(set2))      # True

# 反过来可以用issuperset或>运算符进行超集判断
print(set2.issuperset(set1))    # True
print(set2 > set1)              # True

如何创建不可变集合？
set1 = frozenset({1, 3, 5, 7})
set跟frozenset的区别就如同list跟tuple的区别
字典
创建字典这个类的目的就是通过关键字（而不是list和元组的第几个）找到相关的值
如何创建字典类型？
# dict函数(构造器)中的每一组参数就是字典中的一组键值对
person = dict(name='王大锤', age=55, weight=60, home='中同仁路8号')
print(person)    # {'name': '王大锤', 'age': 55, 'weight': 60, 'home': '中同仁路8号'}

如何将两个列表并成一个字典？
# 可以通过Python内置函数zip压缩两个序列并创建字典
items1 = dict(zip('ABCDE', '12345'))
print(items1)    # {'A': '1', 'B': '2', 'C': '3', 'D': '4', 'E': '5'}
items2 = dict(zip('ABCDE', range(1, 10)))
print(items2)    # {'A': 1, 'B': 2, 'C': 3, 'D': 4, 'E': 5}

如何根据关键字(key)遍历/修改字典？
person = {'name': '王大锤', 'age': 55, 'weight': 60, 'office': '科华北路62号'}
print(len(person))    # 4
if 'age' in person:
    person['age'] = 25
# 通过索引操作向person字典中存入新的键值对
person['tel'] = '13122334455'
#直接添加新的键值
for key in person:
    print(f'{key}: {person[key]}')

for key, value in students.items():
    print(key, '--->', value)


字典中的键必须是不可变类型，例如整数（int）、浮点数（float）、字符串（str）、元组（tuple）等类型的值；显然，列表（list）和集合（set）是不能作为字典中的键的，当然字典类型本身也不能再作为字典中的键，因为字典也是可变类型，但是字典可以作为字典中的值。

# 字典中的值是一个字典(嵌套的字典)
students = {
    1001: {'name': '狄仁杰', 'sex': True, 'age': 22, 'place': '山西大同'},
    1002: {'name': '白元芳', 'sex': True, 'age': 23, 'place': '河北保定'},
    1003: {'name': '武则天', 'sex': False, 'age': 20, 'place': '四川广元'}
}

# 使用pop方法通过键删除对应的键值对并返回该值
stu1 = students.pop(1002)
print(stu1)             # {'name': '白元芳', 'sex': True, 'age': 23, 'place': '河北保定'}

# 使用popitem方法删除字典中最后一组键值对并返回对应的二元组
# 如果字典中没有元素，调用该方法将引发KeyError异常
key, value = students.popitem()
print(key, value)    # 1003 {'name': '武则天', 'sex': False, 'age': 20, 'place': '四川广元'}

# setdefault可以更新字典中的键对应的值或向字典中存入新的键值对
# setdefault方法的第一个参数是键，第二个参数是键对应的值
# 如果这个键在字典中存在，更新这个键之后会返回原来与这个键对应的值
# 如果这个键在字典中不存在，方法将返回第二个参数的值，默认为None
result = students.setdefault(1005, {'name': '方启鹤', 'sex': True})
print(result)        # {'name': '方启鹤', 'sex': True}
print(students)      # {1001: {...}, 1005: {...}}

# 使用update更新字典元素，相同的键会用新值覆盖掉旧值，不同的键会添加到字典中
others = {
    1005: {'name': '乔峰', 'sex': True, 'age': 32, 'place': '北京大兴'},
    1010: {'name': '王语嫣', 'sex': False, 'age': 19},
    1008: {'name': '钟灵', 'sex': False}
}
students.update(others)
print(students)      # {1001: {...}, 1005: {...}, 1010: {...}, 1008: {...}}

函数
带默认值和不带默认值的函数变量需要怎么排放顺序？
带默认值的参数必须放在不带默认值的参数之后，否则将产生SyntaxError错误，错误消息是：non-default argument follows default argument，翻译成中文的意思是“没有默认值的参数放在了带默认值的参数后面”。
不确定输入几个输入，如何定义函数自变量？
# 用星号表达式来表示args可以接收0个或任意多个参数
def add(*args):
    total = 0
    # 可变参数可以放在for循环中取出每个参数的值
    for val in args:
        total += val
    return total


# 在调用add函数时可以传入0个或任意多个参数
print(add())
print(add(1))
print(add(1, 2))
print(add(1, 2, 3))
print(add(1, 3, 5, 7, 9))

如何引用别的文件的函数？
一般的用法
import module1

module1.foo()

注意：

如果我们如果从两个不同的模块中导入了同名的函数，后导入的函数会覆盖掉先前的导入.
from module2 import foo
from module1 import foo

foo()    # module1:hello, world!

在C语言中变量其实是程序可操作的储存区的名称。每个变量都有其特定的类型，类型决定了变量储存的大小和布局，该范围内的值都可以储存在内存中。变量的名称可以由字母，数字和下划线组成。
我们可以先从最简单的整数说起。

一、变量

首先我们需要在内存中找一块区域，规定用它来存放整数，并起一个好记的名字，方便以后查找。例如：



在这里因为a的值可以改变，所以a被叫做变量。
当我们在编译器里敲下如下代码“int a;”时，编译器在运行时，会帮我们在内存中，开辟一个int类型的空间，空间大小由变量的类型决定，在下面的“二、数据类型”中，有详细记载。这个过程，就叫做变量定义。a=123;把 123 交给了变量 a，我们把这个过程叫做给变量赋值。
二、数据类型

数据类型是用来说明数据的类型，确定数据的解释方式

在C语言中有很多数据类型，例如：




说明
数据类型




字符型
char


整型
int


短整型
short


长整形
long


单精度浮点型
float


双精度浮点型
double


无类型
void


三、数据的长度

在C语言中，每一种数据类型所占用的字节数都是固定的，知道了数据类型，也就知道了数据的长度。

在32位环境中，各种数据类型的长度为：




数据类型
长度




char
1


int
4


short
2


long
4


float
4


double
8


最后：数据是放在内存中的，在内存中存取数据要明确三件事：数据存储在哪里，数据点长度和数据的处理方式。