精华内容
下载资源
问答
  • 因为在代码执行之前需要先编译2、在编译阶段,变量和函数会被存放在变量环境中,变量的值会被设置为undefined 3、在执行阶段,js引擎会从变量环境中查找自定义的变量和函数因此我们知道 js的执行机制是:先编译,后...

    JS执行流程&变量提升

    59194b25b876af174ac55051ae2a3ecc.png
    在这里插入图片描述

    一段代码的执行

    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 被执行')
    }

    d1de8dccf2d212e22a5f8aa53e6e387a.png我们可以看到函数showName()已经执行成功,但是console.log(myname)输出undefined此时我们的 myname 是在声明之前执行,于是它输出结果为undefined, 那如果它没有声明呢?5b62df020af6a87e70fd445602209474.png可以看到当我们把声明变量的代码注释之后,没有返回undefined,而是报错了。从上面的例子可以得到下面三个结论:

    1. 使用了未声明的变量,那么js执行会报错
    2. 在一个变量定义之前使用它,不会报错,但是该变量的值为undefined,而不是之后会定义的值
    3. 在一个函数定义之前使用它,不会出错,函数能正确执行。

    第一个结论很好理解,未声明报错。那第二,三个呢?让我们看看之前说过的所谓变量提升:javascript引擎把变量的声明部分函数的声明部分提升到了代码开头的“行为”,同时会给变量设置默认值undefined

    那么刚才的代码在变量提升之后就应该是这样的代码

    //变量提升
    var myname = undefined //变量声明
    function showName(){    //函数声明
      console.log('函数 showName 被执行')
    }

    //可执行代码
    showName()
    console.log(myname)
     myname = 'jingda'

    相信这样写你会更加明白可以在定义之前使用变量或者函数的原因:函数和变量在执行之前都提升到了代码的开头;

    文章总结:

    Javascrip的执行流程a5f61830e4bc3f9d470aabd2a9616668.png

    1、编译阶段 存在变量提升:这里注意,实际上变量和函数声明在代码里的位置是不会改变的,而是在编译阶段被javascript引擎放入内存中。再拿刚才的例子 第一部分:变量提升部分的代码

    var myname = undefined //变量声明
    function showName(){    //函数声明
      console.log('函数 showName 被执行')
    }

    第二部分:执行部分的代码

    showName()
    console.log(myname)
     myname = 'jingda'

    把javascript的执行过程细化3418bbfa7ca1fa026151930347530d29.png可以看出:输入一段代码,编译之后,会生成两部分内容:执行上下文可执行代码执行上下文是javascript执行一段代码时的运行环境

    这样说明一下:执行上下文里面应该是这样的:在后面学习有关执行上下文的时候会再说明。ab4683d1c98203b66a33c48eb87a80f9.png

    2、执行阶段 js引擎开始执行“可执行代码”,按照顺序一行行的执行。

    ‘一起学习吧’ 

    - END -
    展开全文
  • 在网上进行相关查找也是给了一知半解,经过在eclipse上的不断尝试和查看java的相关源码后,我将网上查到的一些关于Calendar变量的常用操作进行了总结。 一:首先我们需要了解Calendar变量: 与Date变量相比,`Date类...

    在进行软件构造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,小于为负数
       
    
    

    参考文章

    展开全文
  • python基本变量和操作

    2021-02-28 10:47:18
    文章目录对变量的基本操作如何查看变量类型?如何将变量的类型强制转化?变量基本运算符的优先级顺序不同逻辑结构分类讨论(分支)连续做相同操作(循环)特殊变量:字符串如何用一个变量储存多行字符串?如何取消...

    文章目录

    对变量的基本操作

    如何查看变量类型?

    type检测变量类型

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

    在这里插入图片描述

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

    运算优先级从上到下

    不同逻辑结构

    分类讨论(分支)

    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语言基础01-变量和数据...变量的名称可以由字母,数字和下划线组成。 我们可以先从最简单的整数说起。 一、变量 首先我们需要在内存中找一块区域,规定用它来存放整数,并起一个好记的名字,方便以后查找。例如: ...

    在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

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

    展开全文
  • 答:变量可以随时变化,在编程时候可以带来很多方便,不然每次要定义一块内存空间来存放数据是非常占用内存,而使用变量就可以只是用这一块空间内存,也方便计算机进行查找等。 3.怎么定义变量? 答:在Python...
  • 内存&&变量&&数据 内存 内存分类 ​ 栈:全局变量/局部变量(函数名在栈空间) ​ 堆:对象(函数本身...​ 每个变量对应一小块内存,变量名用来查找对应内存,变量值就是内存中对应数据 三者之间
  • public static void main(String[ ] args)为java程序入口方法,JVM在运行时会首先查找main方法。public是权限修饰符,表明任何类或对象都可以访问这个方法static表明main()方法是一个静态方法,也就是代码储存在...
  • 二分查找

    2018-03-29 00:34:48
    所谓的二分查找呢,其实就是一种简化版的查找吧,只不过不同于完全版的遍历,它是通过对顺序非降次数列的折半去减少遍历的次数从而降低查找元素时的时间复杂度。 首先我们定义两个变量进行动态储存,分别是L和R,...
  • 1. 思路 1.1 遍历思路 (1)前序 打印当前节点数值 ...设置临时节点变量node,用于储存找到节点(初始化为null) 查询左树 若左树非空,递归左树,并将返回结果赋值给临时变量node 递归完成,若node非null,
  • 指针(pointer)是 C 语言最重要的(有时也是最复杂的)概念之一,用于储存变量的地址。前面使用的scanf()函数中就使用地址作为参数。概括的说,如果主调函数不使用return返回的值,则必须通过地址才能修改主调函数...
  • 指针:用于储存变量的地址 前面使用的scanf()函数中就使用地址作为参数 概括的说:** 如果主调函数不使用return返回的值,则必须通过地址才能修改主调函数中的值 ** 带地址参数的函数,介绍:& 一元&运算符...
  • 在编写一个MySQL储存过程时候,出现了以上报错 检查了一下发现自己既没有拼写错误,也应该没有语法错误,上网查找资料也没有找到相似问题。然后在大佬帮助下写一些小demo找出了问题所在。 放结论 需要在使用...
  • 一. 基本数据类型和引用数据类型区别。  1.基本数据类型:基本数据类型就是简单... 2)引用数据类型赋值,是把引用地址赋给他,在修改属性时候,通过地址查找然后修改。  引用数据类型如何操作?  ...
  • 由于要相加两个三元组表都是给拍好顺序(很好,非常好),所以只要用两个变量依次遍历两个三元组表就OK了,不需要深层查找是否有相符2.设k指向A矩阵某元素,i指向B矩阵某元素,如果k行列都与i相同,就把...
  • 在使用储存过程中,声明了游标 delimiter // drop PROCEDURE if exists adjust_proc; create procedure adjust_proc() begin DECLARE done BOOLEAN ... -- 这里是将所需要的变量查找出来,声明为游标 declare c...
  • 在文件系统中加载和查找数据 pwd 显示出当前路径 cd 移动到某个路径 ls 显示出我路径里东西 我选是桌面,所以。。。。。 ...load 加载文档(前提文档得在桌面,前面已经...显示obtave里所有变量(包括文件名) ...
  • 如果之后想继续使用原始图像,应该将原始图像储存到其他变量中。 在OpenCV中,查找轮廓就像在黑色背景中找白色物体。你应该记住,要找物体应该是白色而背景应该是黑色。 如何在一个二值图像中查找轮廓。 函数cv...
  • 今天,我在 Windows 上用 Python3 爬取知乎上有关中医问答,但是在把...经过上网查找,发现问题原因在于 Python3 对字符串默认编码是Unicode,而爬取内容,正是储存在字符串变量里。 而使用代码创建CSV时,Wind
  • 指针(pointer)是C语言最重要(也是最复杂的概念之一)用于储存变量的地址。sancf()函数中就是用了变量地址作为参数。概括的说,如果主调函数不通过return来返回函数的值,那么就需要通过地址才能修改主调函数中的值 ...
  • 作用域:储存变量并且之后方便找到这些变量的一套规则。(或者说是根据名称查找变量的一套规则) 1、编译原理 1、javaScript是一门编译语言。虽然javaScript引擎编译语言的步骤和传统的编译语言很相似,但是,与...
  • 每个变量都对应一小块内存,变量名用来查找对应内存,变量值就是内存中保存数据 3.内存 内存是指内存条通电后产生储存数据空间(临时) 一块内存包含两个数据: 内部存储数据 地...
  • 基本数据类型和引用数据类型的区别 1、储存位置不同 a、基本数据类型存放在栈... 因为堆中的数据大小不一,无序,杂乱,不能把它放在栈中,否则会降低变量查寻的速度,所以放在变量的栈空间中的值是该对象存储在堆...
  • 对数据结构理解

    2020-07-17 08:56:20
    2、由有限个相同类型的变量所组成有序集合,按一定顺序储存; 3、查找速率快,利用索引方式进行查找,第一元素索引为0,插入和删除速率较慢,因为需要移动大量节点; 4、定义动态数组方法: 第一种...
  • 知乎爬取要点

    2020-12-13 21:41:30
    搜索 浏览器登录 ...python 内自定定义函数输入变量和返回变量很好用,要灵活使用,特别是将内容储存到list[]时候,方便最后储存到excel不至于一坨 一般是在主函数給一个空列表,作为输入变量到def.
  • 字节对齐 :变量在内存中储存都是以字节数为单位,每一个字节都有自己的地址,逻辑上变量的首地址(第一个字节的地址)可以是任意位置,但实际不同类型变量其首地址是有一定规则的,这是为了更快的查找便于存取...
  • 储存系统中目录,在命令行中执行命令时候系统会自动去这些目录中查找命令位置。 比如说要打开迅雷程序,通过命令行打开步骤。 1.将迅雷安装目录放到系统变量path里面。 2.重启命令行执行thunder即可打开...
  • 文章目录写在前面正片语言工具类Java实现线程两种方式集合List集合ArrayListLinkedListSet集合HashSet二叉查找树TreeSetLinkedHashsetMap集合TreeMapHashTableJVM方法区:(被加载信息,常量,静态变量编译后...
  • 作用域是啥我们都知道,所有编程语言都可以存储变量当中值,并在之后程序需要时候查找或者修改它,这样就把储存和访问值能力带给了程序。那么这些值它跑哪去了呢,我们从哪里可以找到它呢。为了解决这个疑惑...
  • ❝“You know nothing Jon Snow”❞深入JavaScript系列01---作用域与闭包这篇文章是对...作用域相关意义:定义了变量储存查找的规则编译原理对于大部分编程语言, 编译大致有三个步骤.分词/词法分析 (Tokenizing/...
  • Python学习笔记:函数

    2016-12-06 15:10:19
    本片参考官方文档: The Python...而变量引用首先查找本地变量表,然后查找上一层函数本地变量表,然后查找全局变量表,最后查找内建(built-in)变量表。所以,全局变量不能直接在一个函数中被赋值(除非声明

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 160
精华内容 64
关键字:

储存变量的查找