a1 = "helloworld"            # 字符串

a1 = [1, 2, 3, 4, 55, 6]     # 列表

a1 = ("aa", "bb")            # 元组

print("类型：",type(a1))  # 查看类型

print("长度：",len(a1))   # 查看长度

for i in a1:    # 遍历

    print(i)

dict1 = {'name': 'pp', 'age': 20, "gender": "man"}    # 字典

for key, val in dict1.items():    # 遍历字典

    print(key, "--", val)

var a1 = "helloworld";              //字符串

var a1 = [1, 2, 3, 4, 55, 6];       //数组

console.log("类型：" +(typeof a1));   // 查看类型

console.log("长度：" + a1.length);    // 查看长度

for (let i=0;i<a1.length;i++){       // 遍历

    console.log(a1[i]);

}

let dict1 = new Map([["a","aa1"], ['b', 'bb2'], ['c', 'ccc']]);    //字典

dict1.forEach(function (value, key) {       // 遍历字典

    console.log(key,value);

})

for (let [key,value] of dict1) {            // 这样遍历也可以

    console.log(key,value);

}

# global示例

num = 1

def fun1():

    global num  # 需要使用 global 关键字声明

    num = 222

    print("函数内部---",num)

print(num)

fun1()

print(num)

, global示例

# nonlocal示例

num = 1

def outer():

    num = 10

    def inner():

        nonlocal num  # nonlocal关键字声明

        num = 100

        print("inner函数内部：",num)

    inner()

    print("outer函数内部：",num)

outer()

print("外部：",num)

, nonlocal示例

const PI = 3.1415    //块级常量，声明一个只读的常量

{

  let a = 10;        //块级变量。新增了let命令

  var b = 1;

}

a, b, c = ""

# a, b, c = [1, 2, "hello"]

# a, b, c = (1, 2, "hello")

# a, b, *c = ["aa", "bb", "cc", "dd"]  # c是列表    c=["cc","dd"]

# a, b, *c = ("aa", "bb", "cc", "dd")  # 同上

print(a)

print(b)

print(c)

let [a, b, c] = '963';

let [a, b, c] = [1, 2, "hello"];

let [a, , c] = ["aa", "bb", "cc", "dd"];    　　　　  // a="aa"    c="cc"

let {a, b , c , d} = {a:"aa",b:"bb",c:"cc",d:"dd"};  // a="aa"    b="bb"   c="cc"   d="dd'

aaa = lambda x: x ** 3  #匿名函数

print(aaa(3))           #

a = map(lambda x: x ** 3, [1, 2, 3, 4, 5])  # map() 会根据提供的函数对指定序列做映射。

print(list(a))          # [1, 8, 27, 64, 125]

let aaa = (x => x**3);     //箭头函数

console.log(aaa(3));       //

let a = [1,2,3,4,5].map((x) => x **3);

console.log(a);            // [1, 8, 27, 64, 125]

f = open("123.txt", 'r', encoding='utf8')

txt1 = f.read()

print(txt1)

f.close() 

var fs = require("fs");

var data = fs.readFileSync('123.txt');

console.log(data.toString());

console.log("程序执行结束!");

#遍历字典

dict = {'first': 'hello', 'second': "world"}

for key, val in dict.items():

    print(key, " : ", val)

//遍历 Map 结构

const map = new Map();

map.set('first', 'hello');

map.set('second', 'world');

for (let [key, value] of map) {

  console.log(key + " is " + value);

}

// first is hello

// second is world

list1 = [11, 22, 33, 44]

it = iter(list1)  # 创建迭代器对象

# print(next(it))   # 输出迭代器的下一个元素

# print(next(it))

for x in it:  # 迭代器对象可以使用常规for语句进行遍历

    print(x)

function* idMaker() {    // 生成器  （ 如果使用function*语法，则函数将变为GeneratorFunction）

  var index = 0;

  while(true)

    yield index++;

}

var gen = idMaker();

console.log(gen.next().value); //

console.log(gen.next().value); //

console.log(gen.next().value); //

'''  iterator, generator。   以下是些基本概念：

iterator:它是这么一个对象，拥有一个next方法，这个方法返回一个对象{done,value}，这个对象包含两个属性，一个布尔类型的done和包含任意值的value

iterable: 这是这么一个对象，拥有一个obj[@@iterator]方法，这个方法返回一个iterator

generator: 它是一种特殊的iterator。反的next方法可以接收一个参数并且返回值取决与它的构造函数（generator function）。generator同时拥有一个throw方法

generator 函数: 即generator的构造函数。此函数内可以使用yield关键字。在yield出现的地方可以通过generator的next或throw方法向外界传递值。generator 函数是通过function*来声明的

yield 关键字：它可以暂停函数的执行，随后可以再进进入函数继续执行 '''

基本概念

# 字符串重复n遍

print("hello"*3)       #hellohellohello

# 替换

str1 = "123aaa321abc".replace("a", "z")    # 替换全部   123zzz321zbc

//字符串重复n遍

console.log( 'hello'.repeat(3) ); // "hellohellohello"

//替换

let str1="123aaa321abc";

let str2 = str1.replace('a', 'z');//普通的只能替换掉一个 123zaa321abc

let str3 = str1.replace(/a/g, 'z');//正则可以替换全部 123zzz321zbc（这是js比较坑的地方，必须用正则，才能实现全部替换）

a = set(["aa", "bb", "cc", "cc"])  # 集合的项是不重复的，加入重复的也没用。集合是无序的。

a.add("dd")  # 集合add方法

a.remove("bb")  # 集合删除方法

print("cc 在集合里吗？ ", "cc" in a)  # 判断是否在集合里    True

print(a)  # {'cc', 'aa', 'dd'}

for item in a:  　　　　　　　　# SET集合的遍历      cc aa dd

    print(item, end=" ")

for i in enumerate(a):  　　  # (0, 'dd') (1, 'cc') (2, 'aa')

    print(i, end=" ")

a = set("abcde")

b = set("defg")

print(a & b)  # 交集  　　　　　　 {'e', 'd'}

print(a | b)  # 合集  　　　　　　 {'b', 'e', 'c', 'd', 'a', 'f', 'g'}

print(a - b)  # 相对补集、差集     {'a', 'b', 'c'}

print(a - b)  # 相对补集、差集      {'g', 'f'}

a = new Set(["aa", "bb", "cc", "cc"])  // 集合的项是不重复的，加入重复的也没用。集合是无序的。

a.add("dd")  // 集合add方法

a.delete("bb")  // 集合删除方法

console.log("cc 在集合里吗？ ", a.has('cc'))  // 判断是否在集合里    True

console.log("集合的长度？ ", a.size)  // 集合的长度

console.log(a)  // {'cc', 'aa', 'dd'}

for (let x of a) { // SET集合的遍历

    console.log(x);

}

let a = new Set(["a","b","c","d","e"]);

let b = new Set(["d","e","f","g"]);

let unionSet = new Set([...a, ...b]);    　　　　　　　　　　　　　　// 并集  {"a", "b", "c", "d", "e","f","g"}

let intersectionSet = new Set([...a].filter(x => b.has(x)));    // 交集{"d", "e"}

let differenceABSet = new Set([...a].filter(x => !b.has(x)));   // 差集 {"a", "b", "c"}