精华内容
下载资源
问答
  • A-Byte-Of-Python3翻译

    2020-09-04 21:20:03
    表示’,可以\’,或者在头尾使用双引号,或者使用三引号。行末的\表示下一行与本行之间没有换行符。类似C++中的raw string,前面加r或R可指定自然字符串。相邻的字符串会被自动连接。 输出中的format方法,类似...

    学的比较粗浅。

    1.python中有整数、浮点数、复数。整数受限于内存大小。双引号等同于单引号,用三引号来指示多行字符串。表示’,可以\’,或者在头尾使用双引号,或者使用三引号。行末的\表示下一行与本行之间没有换行符。类似C++中的raw string,前面加r或R可指定自然字符串。相邻的字符串会被自动连接。
    输出中的format方法,类似printf+setf,可以调整格式。
    标识符不能以数字开头,大小写敏感,只能用数字、字母、下划线。可以使用中文。
    python中的任何东西都是对象。
    变量不需要声明类型,可以直接初始化。
    python默认一行一句,若一行多句可用;间隔。使用缩进来决定语句的层次,

    2.定义了字符串与整数的*操作;x**y为x的y次方;定义了浮点数的%求余;//为取整除 - 返回商的整数部分(向下取整);&、|、^为按位与、或、异或;~x为-(x+1);比较操作符可连接;not为非操作,类似!;and、or为和、或操作;in和not in为从属关系,is和not is为是否关系。优先级见p25。

    3.有if、while、for三种控制流语句,没有switch,某些场合下用字典代替。条件后跟:,while后可选else,for后也可选else。break用于跳出,注意,对应的else部分不会执行;continue。

    4.range函数,提供第一个参数到第二个参数的序列(不含第二个参数),步长为1,可用第三个参数调整步长。len函数返回字符串的长度。

    5.函数:用关键字def定义,如
    def 函数名(参数表):
    函数体

    使用global语句来调用block外的变量。可以同时声明多个变量。
    非局部:用于定义函数中的函数,介于局部和全局之间,nonlocal
    函数的参数默认值也需要从右到左,但调用时可以只给出其中几个值而忽略其他值来使用默认参数,这时参数的顺序可以乱序。
    参数个数不确定,可以使用*。单个*可以将参数收集为一个列表,**则可以将参数收集为字典。后面要输入非列表中的参数,需要用keyword-only参数,如果仅想使用keyword-only参数,可以使用后面不带名字,然后接一个k-o参数。
    return用于退出函数,单独的return等同return None。pass代表空语句块。
    Docstring,在模块、类或者函数中,用三引号括起来的部分,是该部分的说明。使用print(对象名.doc)可以打印其说明文档。其首行以大写字母开始、句号结束,第二行为空行,第三行开始说明。help就是抓取docstring,按q可退出help。

    6.模块:类似C中多个源文件。要使用某个模块,可import之,如果不是内置的模块,解释器会在sys.path中列出的路径中查找(其第一个元素就是当前目录),找到后运行这个模块,这个初始化过程仅在第一次导入时运行。
    在执行python XXX.py 参数表 时,会将参数表传递给XXX.py模块,用sys.argv列表可查看参数列表,其中sys.argv[0]元素是脚本名称。查看os.getcwd()可获取当前目录。

    为了使导入模块变快,会自动创建按字节编译的pyc文件,在当前目录,若没有写权限则不会创建。pyc文件与平台无关。

    如果想导入sys中的argv、使其可以直接使用而不加sys.,可from sys import argv,或者导入sys中全部:from sys import *(但不会导入双下划线开头的对象),一般应避免这样使用。

    每个模块都有__name__,若其为’main’说明这个模块类似含有main函数。此可用来避免import模块时其自动运行一次。

    dir()函数可以列出模块中的标识符(类,函数,变量),给其空参数则会列出本模块的标识符。del语句可以删除变量或名字。

    包是一个文件夹,含有多个模块,其中有一个__init__.py文件来指明该文件夹包含python模块。包可嵌套。

    7.数据结构:列表、元组、字典、集合。
    列表list用[]包括,元素间用逗号分隔,有序。可以用append方法来在列表尾部添加元素。对列表使用len会计数其元素个数。列表还可以使用sort方法,或者用del删除某个元素。列表中的元素类型可以不同,比如一个字符串和整数在同一个列表中。列表可嵌套。

    元组和列表类似,但像字符串一样不可变,用()包括(也可以不带括号)。含一个元素的元组需要在该元素后加逗号,来区别括号表达式。

    字典:键值对,键要求唯一且不可变,比如字符串做键,值可变。字典用{}包括,每个对之间用逗号分隔,键与值间用:分隔,为 键:值 。字典无序,可以自己排序。del 字典名[键] 可以删除该键值对,使用 字典名[键]=值 来添加键值对。使用 for x,y in 字典名.items(): 可遍历字典(items返回元组的列表)。

    元组、字符串和列表都是序列,有切片操作。[x:y:z],从x开始到y之前(不包括y)的元素,步长为z(省略时为1),x省略默认为从开头开始,y省略默认到结尾(包括结尾)。[::-1]表示倒序。

    集合:无序。用set([])来表示,用in来查看有无元素,copy方法来复制集合,add方法增加元素,issuperset方法来判断子集,remove方法删除元素,&或intersection方法求交集。

    8.变量赋值导致引用、alias,slicing可以创建拷贝。

    字符串都是str类,方法众多。startswith(pattern),检验是否以pattern开头;find§,返回位置,找不到返回-1;p.join(str类序列),在str类序列中加入p作为分隔符,并返回这个大字符串。

    9.路径中有空格时需要再加双引号。cmd只能识别双引号。
    time库中有一些时间的输出格式。
    os提供与系统的交互。os.system()向shell输出字符串命令,os.path.exists()判断路径是否存在,os.mkdir()创建路径。
    10.类使用class定义,类的方法也有隐藏的this指针,即self参数。self参数在写方法时必须要加上。类的方法也可以在不实例化时使用。
    构造函数,可以自己定义,方法名为__init__。
    在类方法前面写的变量是类变量,由所有对象共享,与c++区别。双下划线开头的数据成员则是每个对象私有。一些不涉及具体对象的方法可定义为静态方法,即在函数结束后写 函数名=staticmethod(函数名) ,对齐def。
    继承:将父类的名称作为一个元组,写成class 子类(父类):
    子类的构造函数不会自动调用父类的构造函数,需要显式调用。

    11.一些str处理:字符串.lower()返回字符串的小写形式;字符串.replace(p1,p2)将其中的p1以p2替换;
    string.punctuation为所有标点符号的序列。

    12.读写文件用file类的对象。
    如f = open(‘test.txt’, ‘w’),以写模式打开test.txt。还有r、a(附加)、b(二进制)等模式,不加参数时默认以r模式打开text文件。f.write(字符串)为向文件写入字符串,f.readline()为读取并返回文件中的一行字符串,可搭配循环使用,遇到EOF时返回空字符。

    用pickle库读写对象:pickle.dump(待写入对象,f),f是一个file对象,待写入对象可以是任意对象。pickle.load(f)为读取文件。

    13.try、except异常处理:后面不带圆括号的except可处理所有异常。一个try应该跟着一个except,如果没有则用默认的except:打印错误信息并退出。如果except块内写continue,就可以不管异常、继续运行。

    可以编写自己的异常类,一个异常类应该直接或间接继承Error或Exception类,然后用raise 异常类来触发这个异常类:

    class ShortInputException(Exception):
        def __init__(self, length, atleast):
            Exception.__init__(self)
            self.length = length
            self.atleast = atleast
    try:
        text = input('Enter something:')
        if len(text) < 3:
            raise ShortInputException(len(text), 3)
    
    except EOFError:#ctrl + D引发,未输入任何东西
        print('please enter something')
    except ShortInputException as ex:#ex为自己写的异常类的对象
        print('ShortInputException: The input was {0} long, expected at least {1}'\
    .format(ex.length, ex.atleast))
    else:
    	print('No exception triggered')
    

    finally:不管怎样都会执行的块。即使except而退出,也会先执行这里。

    try:
    	a = int(input("请输入 a 的值:"))
    	print(20/a)
    except:
    	print("发生异常!")
    else:
    	print("执行 else 块中的代码") 
    finally :
    	print("执行 finally 块中的代码")
    

    上例中的else必须搭配except,且在except的后面。

    with也能起类似的作用。具体看https://developer.ibm.com/zh/articles/os-cn-pythonwith/
    浅谈:起到类似 try:
    except:
    finally:的作用;代码更少,还有其他好处。
    只能用于有上下文管理器,即有__enter__() 和__exit__()方法的对象。enter()方法会在with的代码块执行之前执行,exit()会在代码块执行结束后执行。exit()方法内会自带当前对象的清理方法。

    14.标准库:
    sys包含系统指定的函数功能;warnings包含一些警告模块;logging得到调试信息:

    #!/usr/bin/python 
    # Filename: use_logging.py 
    import os, platform, logging 
    if platform.platform().startswith('Windows'): 
    logging_file = os.path.join(os.getenv('HOMEDRIVE'), 'test.log') 
    else: 
    	logging_file = os.path.join(os.getenv('HOME'),'test.log') 
    	logging.basicConfig( 
    	level = logging.DEBUG, 
    	format = '%(asctime)s : %(levelname 
    	)s : %(message)s', 
    	filename = logging_file, 
    	filemode = 'w', 
    	) 
    	logging.debug("Start of the program") 
    	logging.info("Doing something") 
    	logging.warning("Dying now") 
    

    其中platform模块可以得到平台信息
    15.其他:
    a,b = (1,2)会使得a为1、b为2,函数可以返回元组。a ,*b = [1,2,3]使得a为1,b为[2,3]。可以用a,b=b,a交换两个变量。
    类的常用方法:在这里插入图片描述
    Lambda表达式:一种函数

    列表综合:根据已有列表生成新列表

    listone = [2,3,4] 
    listtwo = [2*i for i in listone if i > 2] #得到[6,8]
    

    exec(字符串)可将字符串作为python语句执行;eval(字符串)则可将字符串作为python表达式求值。

    assert:声明某个条件必须满足,不满足则会引发错误并退出程序。

    repr函数用来取得对象的规范字符串表示。大多数时候都有eval(repr(object)) == object。需要类有__repr__方法。

    展开全文
  • 表示字面量文本 在程序中字符串字面量使用引号来书写。 # 单引号(Single quote) a = 'Yeah but no but yeah but...' # 双引号(Double quote) b = "computer says no" # 三引号(Triple quotes) c = ''' Look ...

    目录 | 上一节 (1.3 数字) | 下一节 (1.5 列表)

    1.4 字符串

    本节介绍处理文本的方法。

    表示字面量文本

    在程序中字符串字面量使用引号来书写。

    # 单引号(Single quote)
    a = 'Yeah but no but yeah but...'
    
    # 双引号(Double quote)
    b = "computer says no"
    
    # 三引号(Triple quotes)
    c = '''
    Look into my eyes, look into my eyes, the eyes, the eyes, the eyes,
    not around the eyes,
    don't look around the eyes,
    look into my eyes, you're under.
    '''
    

    通常,字符串只能占一行。三引号捕获在引号结束之前的所有文本,包含所有的格式。

    使用单引号(’)和双引号(“)没有区别。但是,以什么样的引号开始字符串,必须以什么样的引号结束字符串。

    字符串转义码

    转义码被用于表示控制字符和不能轻易在键盘上输入的字符。以下是一些常见的转义码:

    '\n'      换行符(Line feed)
    '\r'      回车符(Carriage return)
    '\t'      制表符(Tab)
    '\''      字面量单引号(Literal single quote)
    '\"'      字面量双引号(Literal double quote)
    '\\'      字面量反斜杠(Literal backslash)
    

    字符串表示

    字符串中的每个字符在内部被存储为所谓的 Unicode “代码点(code-point)”,代码点是一个整数。可以使用下列转移序列指定确切的代码点 。

    a = '\xf1'          # a = 'ñ'
    b = '\u2200'        # b = '∀'
    c = '\U0001D122'    # c = '𝄢'
    d = '\N{FOR ALL}'   # d = '∀'
    

    所有可用的字符码请参考 Unicode 字符数据库

    字符串索引

    可以像访问数组那样访问字符串的单个字符。你可以使用从 0 开始的整数索引,负索引指定相对于字符串尾部的位置。

    a = 'Hello world'
    b = a[0]          # 'H'
    c = a[4]          # 'o'
    d = a[-1]         # 'd' (end of string)
    

    你也可以指定一个索引范围来切割或者选择子串:

    d = a[:5]     # 'Hello'
    e = a[6:]     # 'world'
    f = a[3:8]    # 'lo wo'
    g = a[-5:]    # 'world'
    

    不包括结尾索引处的字符。缺失的索引假定为字符串的开始或者结尾。

    字符串操作

    字符串的操作包括:拼接,长度计算,成员判断和复制。

    # Concatenation (+)
    a = 'Hello' + 'World'   # 'HelloWorld'
    b = 'Say ' + a          # 'Say HelloWorld'
    
    # Length (len)
    s = 'Hello'
    len(s)                  # 5
    
    # Membership test (`in`, `not in`)
    t = 'e' in s            # True
    f = 'x' in s            # False
    g = 'hi' not in s       # True
    
    # Replication (s * n)
    rep = s * 5             # 'HelloHelloHelloHelloHello'
    

    字符串的方法

    字符串具有对数据执行各种操作的方法。

    示例:删除开头或者结尾处的任何空白。

    s = '  Hello '
    t = s.strip()     # 'Hello'
    

    示例:大小写转换。

    s = 'Hello'
    l = s.lower()     # 'hello'
    u = s.upper()     # 'HELLO'
    

    示例:文本替换。

    s = 'Hello world'
    t = s.replace('Hello' , 'Hallo')   # 'Hallo world'
    

    更多字符串方法:

    字符串具有各种各样的方法用于测试和处理文本数据。

    下面是字符串方法的一小部分示例:

    s.endswith(suffix)     # Check if string ends with suffix
    s.find(t)              # First occurrence of t in s
    s.index(t)             # First occurrence of t in s
    s.isalpha()            # Check if characters are alphabetic
    s.isdigit()            # Check if characters are numeric
    s.islower()            # Check if characters are lower-case
    s.isupper()            # Check if characters are upper-case
    s.join(slist)          # Join a list of strings using s as delimiter
    s.lower()              # Convert to lower case
    s.replace(old,new)     # Replace text
    s.rfind(t)             # Search for t from end of string
    s.rindex(t)            # Search for t from end of string
    s.split([delim])       # Split string into list of substrings
    s.startswith(prefix)   # Check if string starts with prefix
    s.strip()              # Strip leading/trailing space
    s.upper()              # Convert to upper case
    

    字符串的可变性

    字符串是“不可变的”或者说是只读的。一旦创建,字符串的值就无法修改。

    >>> s = 'Hello World'
    >>> s[1] = 'a'
    Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    TypeError: 'str' object does not support item assignment
    >>>
    

    所有处理字符串数据的操作和方法始终会创建一个新的字符串。

    字符串转换

    使用 str() 函数可以将任何值转换为字符串。 str() 函数得到的结果是一个字符串,该字符串包含的文本与 print() 语句产生的文本相同。

    >>> x = 42
    >>> str(x)
    '42'
    >>>
    

    字节字符串

    通常,在底层 I/O 中会遇到 8 位字节的字符串(译注:字节字符串),它是这样写的:

    data = b'Hello World\r\n'
    

    通过把小写的 b 放到第一个引号之前来指定一个字节字符串而不是文本字符串(译注:在字符串前面加 b 表示这是使用 ASCII 编码的字节字符串)。大部分常用的文本字符串操作可应用于字节字符串。

    len(data)                         # 13
    data[0:5]                         # b'Hello'
    data.replace(b'Hello', b'Cruel')  # b'Cruel World\r\n'
    

    字节字符串索引有点不同,因为它返回的是整数形式的字节值:

    data[0]   # 72 (ASCII code for 'H')
    

    字节字符串与文本字符串之间的转换:

    text = data.decode('utf-8') # bytes -> text
    data = text.encode('utf-8') # text -> bytes
    

    'utf-8' 这个参数指定了字符的编码方式。其它常见的编码方式有 'ascii''latin1'

    原始字符串

    原始字符串是未解释的带有反斜杠的字符串字面量。通过在原始引号之前添加 “r” 前缀来指定。

    >>> rs = r'c:\newdata\test' # Raw (uninterpreted backslash)
    >>> rs
    'c:\\newdata\\test'
    

    输出的字符串是包含在引号里面的字面量文本,与输入的文本完全相同。这在反斜杠有特殊意义的情况下很有用。例如:文件名、正则表达式等。

    f-Strings

    具有格式化表达式替换的字符串。

    >>> name = 'IBM'
    >>> shares = 100
    >>> price = 91.1
    >>> a = f'{name:>10s} {shares:10d} {price:10.2f}'
    >>> a
    '       IBM        100      91.10'
    >>> b = f'Cost = ${shares*price:0.2f}'
    >>> b
    'Cost = $9110.00'
    >>>
    

    注意: 这要求 Python 3.6 或者更新的版本. 格式化代码的含义稍后介绍。

    练习

    在这些习题中,你将尝试对 Python 字符串类型进行操作。你应该在 Python 交互提示符下操作,在该提示符下可以轻松地查看到结果。重要提示:

    在应该与解释器进行交互的习题中,
    >>>当 Python 希望你输入一个新的语句, 你将获得一个解释器提示符。习题中某些语句会跨越多行——要使这些语句执行,你可能需要多按几次回车键。提醒你,在做这些示例时,请勿输入 >>> 提示符。

    通过定义一个包含一系列股票代号的字符串开始吧。字符串如下所示:

    >>> symbols = 'AAPL,IBM,MSFT,YHOO,SCO'
    >>>
    

    练习 1.13:提取单个字符和子串

    字符串是字符数组。尝试提取一些字符:

    >>> symbols[0]
    ?
    >>> symbols[1]
    ?
    >>> symbols[2]
    ?
    >>> symbols[-1]        # Last character
    ?
    >>> symbols[-2]        # Negative indices are from end of string
    ?
    >>>
    

    在 Python 语言中,字符串是只读的。

    尝试通过将 symbols 字符串的第一个字符变为小写字母 ‘a’ 来验证这一点。

    >>> symbols[0] = 'a'
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'str' object does not support item assignment
    >>>
    

    练习 1.14:字符串拼接

    尽管字符串数据是只读的,但是你始终可以将变量重新分配给新创建的字符串。

    尝试下面的语句,该语句将一个新的股票代码 “GOOG” 拼接到 symbols 字符串的末尾。

    >>> symbols = symbols + 'GOOG'
    >>> symbols
    'AAPL,IBM,MSFT,YHOO,SCOGOOG'
    >>>
    

    糟糕!这不是我们想要的。修改它使得变量 symbols 保存的值为 'AAPL,IBM,MSFT,YHOO,SCO,GOOG'

    >>> symbols = ?
    >>> symbols
    'AAPL,IBM,MSFT,YHOO,SCO,GOOG'
    >>>
    

    'HPQ' 添加到 symbols 字符串的前面:

    >>> symbols = ?
    >>> symbols
    'HPQ,AAPL,IBM,MSFT,YHOO,SCO,GOOG'
    >>>
    

    在这些示例中,表面上看起来原始字符串像正在被修改,明显违反了字符串是只读的。实际上不是这样的。每次,这些操作都会创建一个全新的字符串。当变量名 symbols 被重新分配,它会指向一个新创建的字符串。然后,旧的字符串被销毁,因为它不再被使用了。

    练习 1.15:成员测试(子串测试)

    尝试使用 in 操作符检查子串。请在交互提示符下尝试这些操作。

    >>> 'IBM' in symbols
    ?
    >>> 'AA' in symbols
    True
    >>> 'CAT' in symbols
    ?
    >>>
    

    为什么检查 AA 的时候返回 True ?

    练习 1.16:字符串方法

    在 Python 交互提示符下,尝试一些新的字符串方法。

    >>> symbols.lower()
    ?
    >>> symbols
    ?
    >>>
    

    请记住,字符串始终是只读的。如果你想要保存操作的结果,你需要把它放置到一个变量中。

    >>> lowersyms = symbols.lower()
    >>>
    

    请尝试更多的操作:

    >>> symbols.find('MSFT')
    ?
    >>> symbols[13:17]
    ?
    >>> symbols = symbols.replace('SCO','DOA')
    >>> symbols
    ?
    >>> name = '   IBM   \n'
    >>> name = name.strip()    # Remove surrounding whitespace
    >>> name
    ?
    >>>
    

    练习 1.17:f-strings

    有时你想创建一个字符串并把其它变量的值嵌入到其中。

    要做到这点,可以使用 f-strings。示例:

    >>> name = 'IBM'
    >>> shares = 100
    >>> price = 91.1
    >>> f'{shares} shares of {name} at ${price:0.2f}'
    '100 shares of IBM at $91.10'
    >>>
    

    练习 1.10 中修改 mortgage.py 程序来使用 f-strings 创建它的输出。

    尝试实现它,使得输出能够很好地对齐。

    练习 1.18:正则表达式

    基本字符串操作的一个局限性在于它们不支持任何类型的高级模式匹配。为此,你需要使用 Python 的 re 模块和正则表达式。正则表达式处理是一个大的主题,这里只是一个简短的示例:

    >>> text = 'Today is 3/27/2018. Tomorrow is 3/28/2018.'
    >>> # Find all occurrences of a date
    >>> import re
    >>> re.findall(r'\d+/\d+/\d+', text)
    ['3/27/2018', '3/28/2018']
    >>> # Replace all occurrences of a date with replacement text
    >>> re.sub(r'(\d+)/(\d+)/(\d+)', r'\3-\1-\2', text)
    'Today is 2018-3-27. Tomorrow is 2018-3-28.'
    >>>
    

    有关 re 模块的更多信息,请查看官方文档:https://docs.python.org/library/re.html

    说明

    当你开始尝试使用解释器时,你总是希望了解更多有关不同对象所支持的操作。例如,如何找出哪些操作是对字符串是有效的?

    根据你的 Python 环境,你可能可以通过 tab 键补全来查看可用方法的列表。例如,尝试输入下面的代码:

    >>> s = 'hello world'
    >>> s.<tab key>
    >>>
    

    如果单击 tab 键没有任何作用,你可以使用 Python 的内建函数 dir()。示例:

    >>> s = 'hello'
    >>> dir(s)
    ['__add__', '__class__', '__contains__', ..., 'find', 'format',
    'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace',
    'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition',
    'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit',
    'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase',
    'title', 'translate', 'upper', 'zfill']
    >>>
    

    dir() 函数生成一个在 (.) 后出现的所有操作的列表。

    使用 help() 函数可以获取有关特定操作的更多信息。

    >>> help(s.upper)
    Help on built-in function upper:
    
    upper(...)
        S.upper() -> string
    
        Return a copy of the string S converted to uppercase.
    >>>
    

    目录 | 上一节 (1.3 数字) | 下一节 (1.5 列表)

    注:完整翻译见 https://github.com/codists/practical-python-zh

    展开全文
  • ^</code> 表示的是“按位异或”。 3. 没有关于为什么星号(*</code>)前加反斜杠(<code>\</code>)的说明。“防止语法错误”是你做了什么</strong>,“加反斜杠”是你如何做到这件事...
  • --单行注释 --[[ [多行注释] --]] -1....str='aspythonstring'--像Phython一样不可变 ...str="aspythonuse"--可以双引号 str=[[  像Phython的多行注释可用于  表示多行字符串一样  方便  ]] bol=nil-
    --单行注释
    --[[
    [多行注释]
    --]]
    -1.变量&控制量
    ----------
    num=23 --数字都是双精度
    str='aspythonstring'--像Phython一样不可变
    str="aspythonuse"--可以双引号
    str=[[
       像Phython的多行注释可用于
       表示多行字符串一样
       方便
         ]]
    bol=nil--未定义;支持垃圾回收
    --缩进只为易读性,像Matlab一样以end结尾
    while num<50 do
     num=num+1--没有++或者+=自增操作符号
     end
     -- IF条件开关
     if num>40 then
     print('>40')
     elseif s~='aspython' then --~=表示!=
         io.write('s is not aspython')--风骚的标准输出
         else
         thisIsGloal=5--驼峰式命名
         --显示声明局部变量(像javascript一样)
          local line=io.read()
          --..作为字符串连接符
          print('凛冬将至'..line)
          end
    --引用未定义的变量将返回nil,这不是错误
    foo=anUnknownVariable--等价于foo=nil
    aBoolValue=false
    --只有nil与false为假:数字0与空字串‘’为真!
    if not aBoolValue then print('false') end
    --像Python一样运用'or'和'and'
    --得到C语言a?b:c的效果;需要b=false或nil的情况
    ans=aBoolValue and 'yes'or'no'
    karLSum=0
    for i=1,100 do--像Matlab一样的递增语法,包含两端,如[1,100]
        karLSum=karLSum+i
    end
    --Step为2递减的方式'100,1,-2'
    for j=100,1,-2 then print(j)end
    --综上,范围可表示为“begin,end[,Step]”
    --另一个循环控制
    num=23
    repeat
    print('凡人必有一死')
    num=num-1
    until num=0
    -2.函数
    --------------
    --递归
    function fib(n)
    if n<2then return 1 end
    return fib(n-2)+fib(n-1)
    end
    a1=adder(9)
    a2=adder(36)
    print(a1(16))-->25
    print(a2(64))-->100
    --遇到不匹配的列表长度时
    --过长的变量将被赋予nil
    --过长的值将被忽略
    x,y,z=1,2,3,4-->4将被忽略
    function bar(a,b,c)
    print(a,b,c)
    return 4,8,15,16,23,42
    end
    x,y=bar('zaphod')
    --x=4,y=8,其余值被忽略
    --函数与其他类型一样为一等公民
    --同样有Local/global之分
    --像javascript一样定义
    function f(x) return x*x end
    f=function(x) return x*x end
    print 'Hello World'--只有一个‘字符'参数时可以省略括号?
    --------------
    -3.表(Table)
    --表示lua中唯一的复合类型
    --像PHP中的数组或Javascript中的Object一样
    --可用作list/dict/map
    --默认以字符串作为Key
    t={key1='value1',key2=false}
    -像javascript一样以.取值
    print(t.key1)-->"value1"
    t.key3={}--加入新的键值对增
    t.key2=nil --销毁一组键值对?
    --理论上任何非nil的变量都可以作为key
    u={['@!#']='qbert',[{}]=1729,[6.28]='tau'}
    print(u[6.28])-->"tau"
    a=u['@!#']--a='qbert'
    b=u[{}]--b=nil;像javascript一样{}会创建新的对象
       --因此不要
    --同字符串一样,只有一个表作为函数参数时可以省略号?
    --为了一个括号增加阅读难度,得不偿失
    function h(x) print(x.key1) end
    h{key1='Sommi~451'}-->"Sonmi~451"
    for key,val in paris(u) do --像Python一样的迭代
    print(key,val)
    end
    --像javascript一样的全局作用域
    _G
    print(_G['_G']==_G)-->true
    --省略key之后即可变身为list
    --实际上是以递增自然数为key
    v={'value1','value2',1.21,'gigawatts'}
    for     i=1,#v do
    print(v[i])
    end
    --------
    -3.1 Metatables & Metamethods
    ----------
    --元表(Metatable>就是表的表,像javascript的原型(prototype)一样
    --为表重载一些元方法(Metamethods?
    f1={a=1,b=2}
    f2={a=2,b=3}
    --s=f1+f2为错
    mm={}
    function mm.__add(x,y)
    sum={}
    sum.a=x.a+y.a
    sum.b=x.b+x.b
    return sum
    end
    setmeatable(f1,mm)
    setmeatable(f2,mm)
    --实际调用f1的metatable中的metatable中的__add(f1,f2)
    --只为f1设置元表也可以
    s=f1+f2--s={a=3,b=5}
    --s2=s+s 为错,s未定义元表
    --__index元方法重载表中key的提取符号'.'
    --相当于继承的实现,在当前的table找不到值时,就会去找他继承的方法
    defaultFavs={animal='gru',food='donuts'}
    myFavs={food='pizza'}
    setmeatable(myFavs,{__index=defaultFavs})
    food=myFavs.food
    --Lua中的值都具有原方法,只有Table可以重载
    --所有元方法如下

    --__add(a,b)    for a+b

    --__sub(a,b)    for a-b

    --__mul(a,b)    for a*b

    --__div(a,b)    for a/b

    --__mod(a,b)    for a%b

    --__pow(a,b)    for  a^b

    --__unm(a)      for -a

    --__concat(a,b) for a..b

    --__Len(a)      for #a

    --__eq(a,b)     for a==b

    --__lt(a,b)     for a<b

    --__le(a,b)     for a<=b

    --__index(a,b)  for a.b

    --__newindex(a,b,c) for a.b=C语言a

    --__call(a,....) for a(...)

    ------
    -3.2 类风格的Table与继承
    ------
    Dog={}                              --1
    function Dog:new()                 --2
    newObj={sound='woof'}               --3
    self.__index=self                   --4
    return setmeatable(newObj,self)     --5
    end
    function Dog:makeSound()              --6
    print('I say'self.sound)
    end
    mrDog=Dog:new()                        --7
    mrDog:makeSound()-->"I say wwoof"

    --1.Dog像类但实际上是Table
    --2.Dog:new(...):=Dog.new(self,..)
    --3.newObj作Dog的实例
    --4.self是Lua中默认的参数,在这里self=Dog
    --继承的时候可以改变
    --self.__index与self的元方法__index不是一回事
    --self={__index=self,metatable={__index=...}}
    --5.setmeatable(newObj,self)相当于setatable(newObj,{__index=self})
    --赋予实例所有类方法
    --6.同2.
    --mrDog=Dog=Dog.new(Dog)


    --4
    -------
    --以下来自文件mod.lua
    local M={}
    local function  sayMyName()
       print('Hrunkner')
    end
    function M.sayHello()
    print('Why Hello there')
     sayMyName()--给这个方法再加一个方法(个人理解)
     end
    return M
    --以上
    --回到主文件mod
    local mod=require('mod')--运行mod.lua中的代码
    --操作同下
    local  mod=(function()
    --像javascript一样
    --[[
    mod.lua中的代码
    ]]--
    end
    )()
    mod.sayHello()-->"Why Hello there"
    mod.sayMyName()-->错!sayMyName()是mod.lua中的局部变量
    --require 返回的值将被缓存
    --即使多次调用require被调用文件也只运行一次
    --mod2.lua包含print("mod2")
    local a=require("mod2")-->"mod2"
    local b=require("mod2")--不输出,实际为b=a
    --dofile 是不缓存的版本的require
    dofile("mod2")-->"mod2"
    dofile("mod2")-->"mod2"
    --loadfile 读取文件但不执行
    --勘误:f=loadfile('mod2'),需要加后缀名,否则找不到文件
    f=loadfile('mod2.lua')
    f()-->"mod2"
    --Loadstring 读取代码字符串
    f=loadstring("print('lua is cool!')")
    f()-->"Lua is cool"
      
    展开全文
  • 串广泛应用于各种专业的信息管理、信息检索、问答系统、机器翻译等系统处理中。 【定义】 串(string)是由零个或多个字符组成的有限序列,一般记作:  S="a1a2a3...an"。 其中,S是串名,用双引号括...

    字符串、简称串,它也是一种重要的线性结构。计算机中处理的大部分数据都是字符串数据,例如,学生学籍信息系统的姓名、性别、家庭住址、院系名称等信息都属于字符串数据。串广泛应用于各种专业的信息管理、信息检索、问答系统、机器翻译等系统处理中。

    【定义】

    串(string)是由零个或多个字符组成的有限序列,一般记作:
       S="a1a2a3...an"。
    其中,S是串名,用双引号括起来的字符序列是串的值,ai(1≤i≤n)可以是字母、数字或其他字符,n是串的长度。当n=0时,S为空串(null string)。

    串中任意一个连续的字符组成的子序列称为该字符的子串。相应的包含子串的串称为主串。通常将字符在串中的序号称为该字符在串中的位置。子串在主串中的位置以子串的第一个字符在主串中的位置来表示。

    例如:a、b、c、d是4个串:

    a="a professor of Northwest University"
    b="Northwest University"
    c="Northwest"
    d="professor"

    它们的长度分别为35、20、9、10,b、c和d都是a的子串,c又是b的子串。b、c和d在a中位置分别是16,16,3,c在b中的位置是1。

    两个串是相等的,只有当两个串长度相等,且串中各个对应位置的字符均相等,两个串才相等。例如,上面的a,b,c,d两辆都不相等。

    值的注意的是,考虑到与C语言表示方法统一,本文的串都是用双引号括起来的,但是,双引号并不属于串本身的内容,双引号的作用仅仅是为了与整型浮点型数据区分开。
     

    【分类】
    串也有两种存储方式:顺序存储和链式存储。最为常用的是串的顺序存储表示,操作起来更为方便。

    【顺序串】

    采用顺序存储结构的串称为顺序串,又称为定长顺序串。一般采用字符型数组存放顺序串。在串的顺序存储结构中,确定串的长度有两种方法:一种是在串的末尾加上一个结束标记,在C语言中,定义一个串时,系统会自动在串的末尾添加‘\0’作为结束标记。例如,定义一个字符数组:

    char str="Northwest University";

    则串"Northwest University"在内存中的存放形式如图所示。

     其中数组名str指向串的起始地址,“\0”表示串的结束。因此串"Northwest University"的长度为20,不包括结束标记“\0”。但是串长度还需要调用函数strlen或者统计字符个数得到。

    另一种方法是增加一个变量length,用它来存放串的长度。例如,用length表示串"Northwest University"长度的方法如图所示。

     【存储结构】

    //存储结构
    typedef struct 
    {
    	char str[MAXSIZE];
    	int Length;
    }SeqString;

    【串的赋值】

    //串的赋值
    void StrAssign(SeqString  *S, char cstr[])
    {
    	int i=0;
    	for (i = 0; cstr[i] != '\0';i++)
    	{
    		S->str[i] = cstr[i];
    	}
    	S->Length = i;
    }

    【判断串是否为空】

    //判断串是否为空
    int StrEmpty(SeqString S)
    {
    	if (S.Length==0)
    	{
    		return 1;
    	}
    	else
    	{
    		return 0;
    	}
    }

    【求串的长度】

    //求串的长度
    int StrLength(SeqString S)
    {
    	return S.Length;
    }

    【串的复制】

    //串的复制
    void StrCopy(SeqString *T, SeqString S)
    {
    	int i;
    	for (i = 0; i < S.Length;i++)
    	{
    		T->str[i] = S.str[i];
    	}
    	T->Length = S.Length;
    }

    【比较两个串的大小】

    //比较两个串的大小
    int StrCompare(SeqString S, SeqString T)
    {
    	int i;
    	for (i = 0; i < S.Length&&T.Length;i++)
    	{
    		if (S.str[i]!=T.str[i])
    		{
    			return (S.str[i] - T.str[i]);
    		}
    
    	}
    	return (S.Length - T.Length);
    }

    【插入串】

    在串的第pos位置插入串T。若插入成功,返回1;否则返回0.
    串的插入操作具体实现分为3种情况:
      第1种情况,在S中插入T后串长不超过能容纳的最长字符,即S->Length+T.Length<=MaxLen
    则先将串S中pos后的字符向后移动Len个位置,然后将串T插入S中即可;
      第2种情况,若将T插入S后,串长超过能容纳的最长字符但T能完全插入S中,即S->Length+T.Length>MaxLen
    则将串S中pos后的字符往后移动Len个位置后,S中的部分字符被舍弃;
      第3种情况,将T插入S中,有S->Length+T.Length>MaxLen且T不能完全被插入S中
    则T中部分字符和S中第Len位置以后的字符均被舍弃。

    /*在串的第pos位置插入串T。若插入成功,返回1;否则返回0.*/
    /*串的插入操作具体实现分为3种情况:
      第1种情况,在S中插入T后串长不超过能容纳的最长字符,即S->Length+T.Length<=MaxLen
    则先将串S中pos后的字符向后移动Len个位置,然后将串T插入S中即可;
      第2种情况,若将T插入S后,串长超过能容纳的最长字符但T能完全插入S中,即S->Length+T.Length>MaxLen
    则将串S中pos后的字符往后移动Len个位置后,S中的部分字符被舍弃;
      第3种情况,将T插入S中,有S->Length+T.Length>MaxLen且T不能完全被插入S中
    则T中部分字符和S中第Len位置以后的字符均被舍弃。*/
    int StrInsert(SeqString *S, int pos, SeqString T)
    {
    	int i;
    	if (pos < 0||pos-1>S->Length)
    	{
    		cout << "插入位置不正确!";
    		return 0;
    	}
    	if (S->Length + T.Length <=MaxLen)
    	{
    		for (i = S->Length + T.Length - 1; i >= pos + T.Length - 1;i--)
    		{
    			S->str[i] = S->str[i - T.Length];
    		}
    		for (i = 0; i < T.Length;i++)
    		{
    			S->str[pos + i - 1] = T.str[i];
    		}
    		S->Length = S->Length + T.Length;
    		return 1;
    	}
    
    	else if (pos+T.Length<=MaxLen)
    	{
    		for (i = MaxLen - 1; i > T.Length + pos - 1;i--)
    		{
    			S->str[i] = S->str[i - T.Length];
    		}
    		for (i = 0; i < T.Length;i++)
    		{
    			S->str[i + pos - 1] = T.str[i];
    		}
    		S->Length = MaxLen;
    		return 0;
    	}
    	else
    	{
    		for (i = 0; i < MaxLen - pos;i++)
    		{
    			S->str[i + pos - 1] = T.str[i];
    		}
    		S->Length = MaxLen;
    		return 0;
    	}
    }
    

    【删除串S中pos开始的len个字符】

    /*删除串S中pos开始的len个字符*/
    int StrDelete(SeqString *S, int pos, int len)
    {
    	int i;
    	if (pos<0||len<0||pos+len-1>S->Length)
    	{
    		cout << "删除位置不合法,参数len不合法!";
    		return 0;
    	}
    	else
    	{
    		for (i = pos + len; i <= S->Length - 1;i++)
    		{
    			S->str[i - len] = S->str[i];
    		}
    		S->Length = S->Length - len;
    		return 1;
    	}
    }
    

    【连接串】

    将串S连接在串T的末尾。串的连接操作可以分为两种情况:
    第1种,连接后串长T->Length+S.Length≤MaxLen,则直接将串S连接在串T的尾部;
    第2种,连接后串长T->Length+S.Length≥MaxLen且串的长度<MaxLen,则串S会有字符丢失。

    /*将串S连接在串T的末尾。串的连接操作可以分为两种情况:
    第1种,连接后串长T->Length+S.Length≤MaxLen,则直接将串S连接在串T的尾部;
    第2种,连接后串长T->Length+S.Length≥MaxLen且串的长度<MaxLen,则串S会有字符丢失。*/
    int StrConcat(SeqString *T, SeqString S)
    {
    	int i, flag;
    	if (T->Length+S.Length<=MaxLen)
    	{
    		for (i = T->Length; i < T->Length + S.Length;i++)
    		{
    			T->str[i] = S.str[i - T->Length];
    		}
    		T->Length = T->Length + S.Length;
    		flag = 1;
    	}
    	else if(T->Length<MaxLen)
    	{
    		for (i = T->Length; i < MaxLen;i++)
    		{
    			T->str[i] = S.str[i - T->Length];
    		}
    		T->Length = MaxLen;
    		flag = 0;
    	}
    	return flag;
    }
    

    【清空串操作】

    /*清空串操作*/
    void StrClear(SeqString *S)
    {
    	S->Length = 0;
    }

     

    展开全文
  • shell编程初学(第一天)

    2015-12-17 21:18:57
    在linux中,shell的意思是对你在终端中打出来的命令进行解释,并翻译的一个工具,shell的脚本有很多,像是bash,dash很多,在这些脚本中,存储着很多的命令, ...""双引号表示字符,里面如果有可执行的命令就执行完命令在输出字
  • 定义:(javascript object notation ) 翻译为JS对象简谱。 js的一个对象表示方式 JSON并不是一种技术,是一种数据格式 格式 {“name”:”value”,”name2”:”value2”} (注意此处标点符号全为英文格式) 要求: ...
  • 翻译:疯狂的技术宅 原文:towardsdatascience.com/python-basi… Python 数据类型 在 Python 中有许多数据类型。最常见的是float(浮点型),int(整型),str(字符串),bool(布尔),list 和 dict(字典)。 ...
  • 中文翻译 string字串没有以双引号结束 解决办法 1、从字面意思直接理解,看是否由于没有以双引号结尾,没有的话加上。 2、’’’…’’'的字符串表示方式,是自Java13开始使用的,如果你使用的是java12及以下版本...
  • condition作为列名,mysql查询错误

    千次阅读 2018-09-12 18:40:03
    我在写一个二手商品交易系统时,想表示”商品成色”,用百度翻译结果是conditon,然后查询时就悲剧了,后来在navicat中写查询语句,当打出conditon时,自动加上了反引号,然后就能查出结果了,经查询原来conditon是...
  • JSON

    2017-08-10 22:57:00
    -中文翻译: JS对象表示法 -JSON是表示数据的一种格式 -JSON实际就是一个字符串 -JSON中的属性名和属性值必须加双引号 -JSON可以被任意的语言任意的平台所识别 -JSON不能加注释 ##### 语法规范 -JSON 对象 '...
  • Erlang 入门(一)

    千次阅读 2013-12-19 16:26:14
    1.数字类型,需要注意两点 ...2.比较难以翻译的概念——atom,可以理解成常量,它可以包含任何字符,以小写字母开头,如果不是以小写字母开头或者是字母之外的符号,需要用单引号包括起来,比如abc,'A
  • { } :表示对象 对象中都有属性名和属性值 其中属性名必须要是用 “” (双引号包含起来) 属性值: 数字:整型、浮点型 字符串:用英文的双引号引起来 boolean:true、false 数组:使用[ ] 来括起来 对象:通过{ } 括...
  • 按行执行换行即表示新的一句语句,解释器读取一行,翻译一行,翻译一行,执行一行,有些旧的版本不识别中文,需要在代码之前添加# * coding:utf-8 * 二、python注释 1.单行注释 python语言中单行注释用的是“#...
  • 3.字符串类型:字符串是以单引号或者双引号括起来的任意文本; 4.布尔型:布尔值只有’True‘,’false‘两个值,注意大小写。 二.变量命名 1.硬性规则  变量名由字母、数字和下划线构成,数字不能开头;  大小写...
  • 对于日志存储,我们记录了sql执行的时间和sql语句,但是怎么分析日志呢。...这里的逗号是英文逗号,使用双引号可以表示一个格子而不会翻译逗号和空格。 在按照csv打开后,在excel中打开就是显示如下: 转载于...
  • 今天找到了一个在github上的JS翻译教程,看起来似乎还可以。 对于我之前看过的一些JS的知识,我应该快速的过一遍比较好,毕竟只是理论看的多。 JS BigInt 类型可以用于表示任意长度的整数,通过将n加到整数字段的末尾...
  • jsp技术知识点

    2018-12-18 18:13:00
    1.jsp被Tomcat翻译成.java文件后,会被放在Tomcat安装目录下的\work\...2.El表达式表示数据,向JavaScript传递参数时,建议每个数据,打上单引号. 转载于:https://www.cnblogs.com/liu1275271818/p/10138890.html...
  • 到数据库的命令运行工具上试运行一下你的 刀具编号 字段在数据库表里面是什么数据类型,如果是整型啊,长整型啊等等之类的不能用单引号引起来的, 单引号引起来的数据在数据库里面表示字符串,还有借用时间字段,...
  • VALUE函数功能将表示数值的文本转换成数值VALUE函数语法VALUE(text)翻译白话格式:VALUE(目标单元格)参数说明Text:为带引号的文本,或对需要进行文本转换的单元格的引用注意事项:1.Text可以是MicrosoftEx...
  • Scattered knowledge2

    2021-02-07 10:01:46
    4.3.1 Unicode与ASCII码 1、计算机内部使用二进制数。...转义序列中的符号作为一个整体翻译,而不是分开翻译。一个专一序列被当做一个字符。 例如:\“”代表双引号。下面语句,System.out.println(He s
  • 什么是json我们在android网络传输中经常用到的xml和json,其中json英文名是JavaScript Object Notation,翻译过来也就是js对象表示法。虽然他不如xml直观但是因为它轻量便捷相对于xml来说省流量,所以现在大多数都是...
  • “扩充”这个词汇来自于微软自己的翻译,意思就是对表示文件路径的字符串进行特殊的处理,具体功能罗列如下:========================================= ~I - 删除任何引号("),扩充 %I %~fI - 将 %I 扩充到一个...
  • 扩充字符串

    2018-11-08 22:16:00
    扩充”这个词汇来自于微软自己的翻译,意思就是对表示文件路径的字符串进行特殊的处理,具体功能罗列如下:========================================= ~I - 删除任何引号("),扩充 %I %~fI - 将 %I 扩充到一个完全...
  • 题意翻译 三个人玩石头剪刀布,问谁赢了。 输入三行,每行一个字符串(rock(石头),scissors(剪刀),paper(布)),分别表示这三个人出的手势。 石头打破剪刀,剪刀剪纸,纸裹在石头上。 当有一个人同时赢过其他...
  • 了解Markdown 到目前为止,我学到了什么。 学习新语言并不容易,这需要时间。 对我的音乐家同事来说,学习一种新的计算机语言,例如Markdown,就像学习如何...我什至可以使用[]表示文本,使用()表示URL链接。 我也可
  • Unexpected end of input解决方法

    万次阅读 2018-10-12 20:46:26
    Unexpected end of input 可以翻译为 “意外的终止输入” 它通常表示浏览器在读取我们的javascript代码时,碰到了不可预知的错误,导致浏览器无法进行下面的解析 一般**“ ”(双引号), ‘ ’(单引号) ,{},...

空空如也

空空如也

1 2
收藏数 39
精华内容 15
关键字:

引号表示翻译