一、运算符

1、算术运算符

%   求余运算

**    幂-返回x的y次幂

//    取整数-返回商的整数部分,例:9//2输出结果是4

2、比较运算符

==  等于

!=  不等于

<>  不等于

>  大于 

<  小于  

>=  大于等于

<=  小于等于

3、赋值运算

=  简单的赋值

+=  加法赋值运算,c += a等效于c = c + a

-=  减法赋值运算

*=  乘法赋值运算

/=  除法赋值运算

%=  取模赋值运算

**=  幂赋值运算符

//=  取整除赋值运算符

4、in

in  如果在指定的序列中找到值返回True,否则返回False

not in  如果在指定的序列中没有找到值返回True,否则返回False

二、基本数据类型

1、数字(int)

def bit_length(self): # real signature unknown; restored from __doc__
"""
int.bit_length() -> int Number of bits necessary to represent self in binary.(用二进制表示自我需要的比特数)
>>> bin(37)
'0b100101'
>>> (37).bit_length()
6
"""
return 0

2、字符串(str)

def capitalize(self): # real signature unknown; restored from __doc__
"""
S.capitalize() -> str Return a capitalized version of S, i.e. make the first character
have upper case and the rest lower case.(返回第一个字符大写,其他小写)
    """
return ""

def casefold(self): # real signature unknown; restored from __doc__
"""
S.casefold() -> str Return a version of S suitable for caseless comparisons.  (将大写变成小写)
"""
return ""


def center(self, width, fillchar=None): # real signature unknown; restored from __doc__
"""
S.center(width[, fillchar]) -> str Return S centered in a string of length width. Padding is
done using the specified fill character (default is a space)  (输出指定长度的字符串,默认不够用空格代替,也可以自己指定
    """
return ""
def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.count(sub[, start[, end]]) -> int Return the number of non-overlapping occurrences of substring sub in
string S[start:end]. Optional arguments start and end are
interpreted as in slice notation.  (统计指定位置内的字符个数)
"""
return 0

def encode(self, encoding='utf-8', errors='strict'): # real signature unknown; restored from __doc__  (编码的意思)
"""
S.encode(encoding='utf-8', errors='strict') -> bytes Encode S using the codec registered for encoding. Default encoding
is 'utf-8'. errors may be given to set a different error
handling scheme. Default is 'strict' meaning that encoding errors raise
a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
'xmlcharrefreplace' as well as any other name registered with
codecs.register_error that can handle UnicodeEncodeErrors.
"""
return b""
 
def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
"""
S.endswith(suffix[, start[, end]]) -> bool Return True if S ends with the specified suffix, False otherwise.(返回True,如果字符串以指定的后缀结尾,否则False)
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
suffix can also be a tuple of strings to try.
"""
return False

def expandtabs(self, tabsize=8): # real signature unknown; restored from __doc__  (把字符串中的Tab符号('\t')转为空格,Tab符号默认的空格数是8个,也可以自己指定)
"""
S.expandtabs(tabsize=8) -> str Return a copy of S where all tab characters are expanded using spaces.  (返回一个字符串,其中所有选项卡字符都使用空格展开。)
If tabsize is not given, a tab size of 8 characters is assumed.  (如果不给定tabsize,假定有8个字符的选项卡大小)
"""
return ""

def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__ 显示位置 (检测字符串中是否包含子字符串str,如果指定开始和结束范围,则检查指定范围内,如果包含子字符串返回开始的索引值,否则返回-1)
"""
S.find(sub[, start[, end]]) -> int Return the lowest index in S where substring sub is found,  (返回找到substring子的字符串中最低索引,这样的子被包含在字符串[start:end]中。可选参数的开始和结束被解释为片表示法)
such that sub is contained within S[start:end]. Optional
arguments start and end are interpreted as in slice notation. Return -1 on failure.
"""
return 0

def format(self, *args, **kwargs): # known special case of str.format  (字符串格式化)
"""
S.format(*args, **kwargs) -> str Return a formatted version of S, using substitutions from args and kwargs.(返回格式化的字符串,使用来自args和kwargs的替换)
The substitutions are identified by braces ('{' and '}').(用括号({'and'}))来标识替换。
"""
pass

def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__  (和find差不多)
"""
S.index(sub[, start[, end]]) -> int Return the lowest index in S where substring sub is found,   (返回找到提交字符串子字符串的最低索引,这样的子被包含在S[start.end]中。可选参数的开始和结束被解释为片表示法)
such that sub is contained within S[start:end]. Optional
arguments start and end are interpreted as in slice notation. Raises ValueError when the substring is not found.
"""
return 0

def isalnum(self): # real signature unknown; restored from __doc__
"""
S.isalnum() -> bool Return True if all characters in S are alphanumeric
and there is at least one character in S, False otherwise.  (如果字符串中的所有字符都是字母数字,返回True,在字符串中至少有一个字符,是False)
"""
return False

def isalpha(self): # real signature unknown; restored from __doc__  (检测字符串是否只由字母组成)
"""
S.isalpha() -> bool Return True if all characters in S are alphabetic
and there is at least one character in S, False otherwise.
"""
return False

def isdecimal(self): # real signature unknown; restored from __doc__  (检查字符串中是否只包含十进制字符)
"""
S.isdecimal() -> bool Return True if there are only decimal characters in S,
False otherwise.
"""
return False
def isdigit(self): # real signature unknown; restored from __doc__  (检查字符串是否由数字组成)
"""
S.isdigit() -> bool Return True if all characters in S are digits
and there is at least one character in S, False otherwise.
"""
return False
def isidentifier(self): # real signature unknown; restored from __doc__  (not important)
"""
S.isidentifier() -> bool Return True if S is a valid identifier according  (如果字符串是有效的标识符,则返回True语言的定义)
to the language definition. Use keyword.iskeyword() to test for reserved identifiers  (使用keyword.is关键词()来测试保留标识符)
such as "def" and "class".
"""
return False
def islower(self): # real signature unknown; restored from __doc__  (not important)
"""
S.islower() -> bool Return True if all cased characters in S are lowercase and there is  (如果在字符串中所有字符都是小写,则返回True。否则False)
at least one cased character in S, False otherwise.
"""
return False
def isnumeric(self): # real signature unknown; restored from __doc__  (检查字符串是否只由数字组成。这种方法只针对unicode对象。)
"""
S.isnumeric() -> bool Return True if there are only numeric characters in S,
False otherwise.
"""
return False
def isprintable(self): # real signature unknown; restored from __doc__  
"""
S.isprintable() -> bool Return True if all characters in S are considered    (如果考虑字符串中的所有字符,返回True)
printable in repr() or S is empty, False otherwise.
"""
return False
def isspace(self): # real signature unknown; restored from __doc__
"""
S.isspace() -> bool Return True if all characters in S are whitespace
and there is at least one character in S, False otherwise.  (如果在字符串中所有字符串都是空格,则返回True)
"""
return False
def istitle(self): # real signature unknown; restored from __doc__
"""
S.istitle() -> bool Return True if S is a titlecased string and there is at least one  (返回True如果字符串是一个标题字符串,至少有一个字符在字符串中,否则为False)
character in S, i.e. upper- and titlecase characters may only
follow uncased characters and lowercase characters only cased ones.
Return False otherwise.
"""
return False
def isupper(self): # real signature unknown; restored from __doc__
"""
S.isupper() -> bool Return True if all cased characters in S are uppercase and there is  (如果字符串中所有字符都是大写,那么返回True,否则False)
at least one cased character in S, False otherwise.
"""
return False
def join(self, iterable): # real signature unknown; restored from __doc__  (用于将序列中的元素以指定的字符连接生成一个新的字符串)
"""
S.join(iterable) -> str Return a string which is the concatenation of the strings in the
iterable. The separator between elements is S.
"""
return ""
def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__  (返回字符串左对齐的字符串长度。填充是通过指定的fillchar(默认为空格)。如果宽度小于len(s)返回原始字符串)
"""
S.ljust(width[, fillchar]) -> str Return S left-justified in a Unicode string of length width. Padding is
done using the specified fill character (default is a space).
"""
return ""

def lower(self): # real signature unknown; restored from __doc__  (转换字符串中所有大写为小写)
"""
S.lower() -> str Return a copy of the string S converted to lowercase.
"""
return ""

def lstrip(self, chars=None): # real signature unknown; restored from __doc__  ()
"""
S.lstrip([chars]) -> str Return a copy of the string S with leading whitespace removed.    (将字符串的副本返回,并删除主要空白)
If chars is given and not None, remove characters in chars instead.    (如果给定字符,而不是None,则删除字符)
"""
return ""
def maketrans(self, *args, **kwargs): # real signature unknown  (用于创建字符映射的转换表,对于接受两个参数的最简单的调用方式,第一个参数是字符串,表示需要转换的字符,第二个参数也是字符串表示转换的目标。)
"""
Return a translation table usable for str.translate().  (两个字符串的长度必须相同,为一一对应的关系) If there is only one argument, it must be a dictionary mapping Unicode
ordinals (integers) or characters to Unicode ordinals, strings or None.
Character keys will be then converted to ordinals.
If there are two arguments, they must be strings of equal length, and
in the resulting dictionary, each character in x will be mapped to the
character at the same position in y. If there is a third argument, it
must be a string, whose characters will be mapped to None in the result.
"""
pass
def partition(self, sep): # real signature unknown; restored from __doc__  (用来根据指定的分隔符将字符串进行分割。如果字符串包含指定的分隔符,则返回一个3元组,第一个为分隔符左边的子串,第二个为分隔符本身,第三个为分隔符右边的子串)
"""
S.partition(sep) -> (head, sep, tail) Search for the separator sep in S, and return the part before it,
the separator itself, and the part after it. If the separator is not
found, return S and two empty strings.
"""
pass
#!/usr/bin/python

str = "http://www.w3cschool.cc/"

print str.partition("://")
输出结果为:
('http', '://', 'www.w3cschool.cc/')

  

def replace(self, old, new, count=None): # real signature unknown; restored from __doc__  (把字符串中的old(旧字符串)替换成new(新字符串),如果指定第三个参数max,则替换不超过max次)
"""
S.replace(old, new[, count]) -> str Return a copy of S with all occurrences of substring
old replaced by new. If the optional argument count is
given, only the first count occurrences are replaced.
"""
return ""
#!/usr/bin/python

str = "this is string example....wow!!! this is really string";
print str.replace("is", "was");
print str.replace("is", "was", 3);
以上实例输出结果如下:
thwas was string example....wow!!! thwas was really string
thwas was string example....wow!!! thwas is really string

  

def rfind(self, sub, start=None, end=None): # real signature unknown; restored from __doc__  (返回字符串最后一次出现的位置(从右向左查询),如果没有匹配项则返回-1)
"""
S.rfind(sub[, start[, end]]) -> int Return the highest index in S where substring sub is found,
such that sub is contained within S[start:end]. Optional
arguments start and end are interpreted as in slice notation. Return -1 on failure.
"""
return 0
#!/usr/bin/python

str = "this is really a string example....wow!!!";
substr = "is"; print str.rfind(substr);
print str.rfind(substr, 0, 10);
print str.rfind(substr, 10, 0); print str.find(substr);
print str.find(substr, 0, 10);
print str.find(substr, 10, 0);
以上实例输出结果如下:
5
5
-1
2
2
-1

  

def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__  (删除string字符串末尾的指定字符(默认为空格))
"""
S.rjust(width[, fillchar]) -> str Return S right-justified in a string of length width. Padding is
done using the specified fill character (default is a space).
"""
return ""
#!/usr/bin/python

str = "     this is string example....wow!!!     ";
print str.rstrip();
str = "88888888this is string example....wow!!!8888888";
print str.rstrip('8');
以上实例输出结果如下:
this is string example....wow!!!
88888888this is string example....wow!!!

  

def rpartition(self, sep): # real signature unknown; restored from __doc__    (根据指定的分隔符将字符串进行分割。如果字符串包含指定的分隔符,则返回一个3元的组,第一个为分隔符左边的子串,第二个为分隔符本身,第三个为分隔符右边的子串)
"""
S.rpartition(sep) -> (head, sep, tail) Search for the separator sep in S, starting at the end of S, and return
the part before it, the separator itself, and the part after it. If the
separator is not found, return two empty strings and S.
"""
pass
#!/usr/bin/python

str = "http://www.w3cschool.cc/"

print str.partition("://")
输出结果为:
('http', '://', 'www.w3cschool.cc/')

  

def split(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__  (通过指定分隔符对字符串进行切片,如果参数num有指定值,则仅分隔num个字符串)
"""
S.split(sep=None, maxsplit=-1) -> list of strings Return a list of the words in S, using sep as the
delimiter string. If maxsplit is given, at most maxsplit
splits are done. If sep is not specified or is None, any
whitespace string is a separator and empty strings are
removed from the result.
"""
return []
#!/usr/bin/python

str = "Line1-abcdef \nLine2-abc \nLine4-abcd";
print str.split( );
print str.split(' ', 1 );
以上实例输出结果如下:
['Line1-abcdef', 'Line2-abc', 'Line4-abcd']
['Line1-abcdef', '\nLine2-abc \nLine4-abcd']

  

def splitlines(self, keepends=None): # real signature unknown; restored from __doc__  (按照行分隔,返回一个包含行作为元素的列表,如果参数keepends为False,不包含换行符,如果为True,则保留换行符)
"""
S.splitlines([keepends]) -> list of strings Return a list of the lines in S, breaking at line boundaries.
Line breaks are not included in the resulting list unless keepends
is given and true.
"""
return []
#!/usr/bin/python

str1 = 'ab c\n\nde fg\rkl\r\n'
print str1.splitlines(); str2 = 'ab c\n\nde fg\rkl\r\n'
print str2.splitlines(True)
以上实例输出结果如下:
['ab c', '', 'de fg', 'kl']
['ab c\n', '\n', 'de fg\r', 'kl\r\n']

  

def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__  (用于检查字符串是否是以指定字符串开头,如果是则返回True,否则)
"""  
S.startswith(prefix[, start[, end]]) -> bool Return True if S starts with the specified prefix, False otherwise.
With optional start, test S beginning at that position.
With optional end, stop comparing S at that position.
prefix can also be a tuple of strings to try.
"""
return False
#!/usr/bin/python

str = "this is string example....wow!!!";
print str.startswith( 'this' );
print str.startswith( 'is', 2, 4 );
print str.startswith( 'this', 2, 4 );
以上实例输出结果如下:
True
True
False

  

def strip(self, chars=None): # real signature unknown; restored from __doc__  (用于移除字符串头尾指定的字符,默认为空格)
"""
S.strip([chars]) -> str Return a copy of the string S with leading and trailing
whitespace removed.
If chars is given and not None, remove characters in chars instead.
"""
return ""
#!/usr/bin/python

str = "0000000this is string example....wow!!!0000000";
print str.strip( '0' );
以上实例输出结果如下:
this is string example....wow!!!

  

def swapcase(self): # real signature unknown; restored from __doc__    (用于对字符串的大小写字母进行转换)
"""
S.swapcase() -> str Return a copy of S with uppercase characters converted to lowercase
and vice versa.
"""
return ""
#!/usr/bin/python

str = "this is string example....wow!!!";
print str.swapcase(); str = "THIS IS STRING EXAMPLE....WOW!!!";
print str.swapcase();
以上实例输出结果如下:
this is string example....wow!!!

  

def translate(self, table): # real signature unknown; restored from __doc__    (根据参数table给出的表(包含256个字符)转换字符串的字符,要过滤掉的字符放到del参数中)
"""
S.translate(table) -> str Return a copy of the string S in which each character has been mapped
through the given translation table. The table must implement
lookup/indexing via __getitem__, for instance a dictionary or list,
mapping Unicode ordinals to Unicode ordinals, strings, or None. If
this operation raises LookupError, the character is left untouched.
Characters mapped to None are deleted.
"""
return ""
#!/usr/bin/python

from string import maketrans   # 引用 maketrans 函数。

intab = "aeiou"
outtab = "12345"
trantab = maketrans(intab, outtab) str = "this is string example....wow!!!";
print str.translate(trantab);
以上实例输出结果如下:
th3s 3s str3ng 2x1mpl2....w4w!!!
以上实例去除字符串中的 'x' 和 'm' 字符:
#!/usr/bin/python from string import maketrans # Required to call maketrans function. intab = "aeiou"
outtab = "12345"
trantab = maketrans(intab, outtab) str = "this is string example....wow!!!";
print str.translate(trantab, 'xm');
以上实例输出结果:
th3s 3s str3ng 21pl2....w4w!!!

  

3.列表(形式:name_list = ["cairui","caicai","aiai"])

def append(self, p_object): # real signature unknown; restored from __doc__  (在列尾末尾添加新的对象)
""" L.append(object) -> None -- append object to end """
pass
#!/usr/bin/python

aList = [123, 'xyz', 'zara', 'abc'];
aList.append( 2009 );
print "Updated List : ", aList;
以上实例输出结果如下:
Updated List : [123, 'xyz', 'zara', 'abc', 2009]

  

def clear(self): # real signature unknown; restored from __doc__    (函数用于清空列表,类似于del a[:])
""" L.clear() -> None -- remove all items from L """
pass
#!/usr/bin/python3

list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
list1.clear()
print ("列表清空后 : ", list1)
以上实例输出结果如下:
列表清空后 : []

  

def copy(self): # real signature unknown; restored from __doc__  (用于复制列表,类似于a[:])
""" L.copy() -> list -- a shallow copy of L """
return []
#!/usr/bin/python3

list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
list2 = list1.copy()
print ("list2 列表: ", list2)
以上实例输出结果如下:
list2 列表: ['Google', 'Runoob', 'Taobao', 'Baidu']

  

def count(self, value): # real signature unknown; restored from __doc__      (用于统计某个元素在列表中出现的次数)
""" L.count(value) -> integer -- return number of occurrences of value """
return 0
#!/usr/bin/python

aList = [123, 'xyz', 'zara', 'abc', 123];

print "Count for 123 : ", aList.count(123);
print "Count for zara : ", aList.count('zara');
以上实例输出结果如下:
Count for 123 : 2
Count for zara : 1

  

def extend(self, iterable): # real signature unknown; restored from __doc__
""" L.extend(iterable) -> None -- extend list by appending elements from the iterable """  (函数用于在列表末尾一次性追加另一个序列中的多个值)
pass
#!/usr/bin/python

aList = [123, 'xyz', 'zara', 'abc', 123];
bList = [2009, 'manni'];
aList.extend(bList) print "Extended List : ", aList ;
以上实例输出结果如下:
Extended List : [123, 'xyz', 'zara', 'abc', 123, 2009, 'manni']

  

def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__  (用于从列表中找出某个值第一个匹配的索引位置)
"""
L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.
"""
return 0
#!/usr/bin/python

aList = [123, 'xyz', 'zara', 'abc'];

print "Index for xyz : ", aList.index( 'xyz' ) ;
print "Index for zara : ", aList.index( 'zara' ) ;
以上实例输出结果如下:
Index for xyz : 1
Index for zara : 2

  

def insert(self, index, p_object): # real signature unknown; restored from __doc__  (用于将指定对象插入列表的指定位置)
""" L.insert(index, object) -- insert object before index """
pass
#!/usr/bin/python

aList = [123, 'xyz', 'zara', 'abc']

aList.insert( 3, 2009)

print "Final List : ", aList
以上实例输出结果如下:
Final List : [123, 'xyz', 'zara', 2009, 'abc']

  

def remove(self, value): # real signature unknown; restored from __doc__  (用于移除列表中某个值的第一个匹配项)
"""
L.remove(value) -> None -- remove first occurrence of value.
Raises ValueError if the value is not present.
"""
pass
#!/usr/bin/python3

list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
list1.remove('Taobao')
print ("列表现在为 : ", list1)
list1.remove('Baidu')
print ("列表现在为 : ", list1)
以上实例输出结果如下:
列表现在为 : ['Google', 'Runoob', 'Baidu']
列表现在为 : ['Google', 'Runoob']

  

def reverse(self): # real signature unknown; restored from __doc__  (用于反向列表中元素)
""" L.reverse() -- reverse *IN PLACE* """
pass
#!/usr/bin/python3

list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
list1.reverse()
print ("列表反转后: ", list1)
以上实例输出结果如下:
列表反转后: ['Baidu', 'Taobao', 'Runoob', 'Google']

  

def sort(self, key=None, reverse=False): # real signature unknown; restored from __doc__  (用于对原列表进行排序,如果指定参数,则使用比较函数指定的比较函数)
""" L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE* """
pass
#!/usr/bin/python3

list1 = ['Google', 'Runoob', 'Taobao', 'Baidu']
list1.sort()
print ("列表排序后 : ", list1)
以上实例输出结果如下:
列表排序后 : ['Baidu', 'Google', 'Runoob', 'Taobao']

  

4、字典(dict)

形式:

user_info = {

  "name":"cairui",

  "age":19,

  "gender":'M'

}

def clear(self): # real signature unknown; restored from __doc__  (用于删除字典内的所有元素)
""" D.clear() -> None. Remove all items from D. """
pass
#!/usr/bin/python3

dict = {'Name': 'Zara', 'Age': 7}

print ("字典长度 : %d" %  len(dict))
dict.clear()
print ("字典删除后长度 : %d" % len(dict))
以上实例输出结果为:
字典长度 : 2
字典删除后长度 : 0

  

def get(self, k, d=None): # real signature unknown; restored from __doc__  (返回指定键的值,如果值不在字典中返回默认值)
""" D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None. """
pass
#!/usr/bin/python3 

dict = {'Name': 'Runoob', 'Age': 27}

print ("Age 值为 : %s" %  dict.get('Age'))
print ("Sex 值为 : %s" % dict.get('Sex', "NA"))
以上实例输出结果为:
Age 值为 : 27
Sex 值为 : NA

  

4、enumerate用法:自动生成一列,默认从0开始自增1,也可以自己指定字符串转换为数字int(字符串)

Python之运算符以及基本数据类型的object的更多相关文章

  1. python之运算符与基本数据类型

    1.开发工具:IDE pycharm(推荐).eclipse 2.运算符 结果是值 算数运算 a = 10 * 10 赋值运算 a = a + 1    a+=1 结果是布尔值 比较运算 a = 1 ...

  2. python,运算符,基本数据类型

    a = 'py' in 'python' b = 'py' not in 'python' print(a)print(b) in :判断一个前面一个字符串中的字符是否完整的出现在后面的字符串中,如果 ...

  3. 跟着ALEX 学python day2 基础2 模块 数据类型 运算符 列表 元组 字典 字符串的常用操作

    声明 : 文档内容学习于 http://www.cnblogs.com/xiaozhiqi/  模块初始: Python的强大之处在于他有非常丰富和强大的标准库和第三方库,几乎你想实现的任何功能都有相 ...

  4. Python学习笔记:02数据类型

    Python 数据类型 python中标准的数据类型有 基础类型 整型(长整型) 浮点型 复数型 布尔型 序列类型 字符串 列表 元组 字典 整型 整型和长整型并不严格区分,整型int的表达范围和计算 ...

  5. Python自动化开发-变量、数据类型和运算

    一.变量 变量定义:Variables are used to store infomation to referrenced and manipulated in a computer progra ...

  6. Python第三天 序列 数据类型 数值 字符串 列表 元组 字典

    Python第三天 序列  数据类型  数值  字符串  列表  元组  字典 数据类型数值字符串列表元组字典 序列序列:字符串.列表.元组序列的两个主要特点是索引操作符和切片操作符- 索引操作符让我 ...

  7. python入门(8)数据类型和变量

    python入门(8)数据类型和变量 数据类型 在Python中,能够直接处理的数据类型有以下几种: 整数 Python可以处理任意大小的整数,当然包括负整数,在程序中的表示方法和数学上的写法一模一样 ...

  8. python的6种基本数据类型--字典

    python的6种基本数据类型--字典   字典 字典的定义与特性 字典是Python语言中唯一的映射类型. 定义:{key1:value1,key2:value2} 1.键与值用冒号":& ...

  9. python基础语法_2基本数据类型

    http://www.runoob.com/python3   大纲 Number(数字) String(字符串) List(列表) Tuple(元组) Sets(集合) Dictionarys(字典 ...

随机推荐

  1. JavaScript 中事件绑定的三种方式

    以下是在 JS 中事件绑定的三种方式.   1. HTML onclick attribute     <button type="button" id="uplo ...

  2. Regexp:template

    ylbtech-Regexp: 1.返回顶部 1.   2. 2.返回顶部   3.返回顶部   4.返回顶部   5.返回顶部     6.返回顶部   7.返回顶部   8.返回顶部   9.返回 ...

  3. 创建github怎样管理

    创建版本库 第一步: 创建一个版本库非常简单,首先,选择一个合适的地方,创建一个空目录 $mkdir learngit $cd learngit $pwd mkdir learngit 创建一个名叫“ ...

  4. 分布式代码管理github

    Git是世界上最先进的分布式版本的控制系统,特点是:简单大气上档次. Linus在1991年创建了开源的Linux,从此,Linux系统不断发展,已经成为最大的服务器系统软件了.

  5. 实验吧CTF题库-编程(部分)

    百米 3秒提交答案,数字是随机变化的 利用Python脚本解题 # -*- coding:utf-8 -*- __author__ = "MuT6 Sch01aR" import ...

  6. 使用SQL Server保存Session状态,实现单点登录

    在做一些应用网站时,我们可能会碰到这样一种情况:整个项目是由多个网站组成的,而我们要实现用户从一个站点登录后,跳转到其他网站不需要重复登录,即实现单点登录.目前实现单点登录的技术也有好几种,这篇文章描 ...

  7. div的作用

    <div></div>主要是用来设置涵盖一个区块为主,所谓的区块是包含一行以上的数据,所以在<div></div>的开始之前与结束后,浏览都会自动换行, ...

  8. struts1-mapping.getInputForward()与mapping.getInput

    转自:https://www.cnblogs.com/azai/archive/2010/06/05/1752416.html 奇怪为什么登陆失败的时候 没有错误提示.这个问题困扰了N久 仔细看了下, ...

  9. css代码结构

    整个文档结构如下: 一般性样式 主体样式 reset样式 链接 标题 其他元素 辅助样式 表单 通知和错误 一致的条目 页面结构 标题.页脚和导航 布局 其他页面结构元素 页面组件 各个页面 覆盖

  10. activity的四种加载模式介绍

      四种加载模式的介绍: a) Standard : 系统默认模式,一次跳转即会生成一个新的实例:    b) SingleTop : 和 standard 类似,唯一的区别就是当跳转的对象是位于栈顶 ...