python 基本數據類型 及 查看對象的類，或對象所具有的功能(幫助)
-
運算符
一、算數運算：python
二、比較運算：git
三、賦值運算：編程
四、邏輯運算：api
五、成員運算：app
- 查看對象的類,或對象所具有的功能
1. 使用type方法：___以下less
test = "ccy"ide
t = type(test)函數式編程
print(t)函數
# str Ctrl + 鼠標左鍵， 找到str類， 內部全部的方法 this
2. dir 方法: __以下示例
test = 「ccy」
b = dir(test)
3. help, type
help(type(test))
4.直接點擊：
test = "ccy"
test.upper()
鼠標放在upper()上， Ctrl+ 鼠標左鍵，自動定位到upper功能處
-
基本數據類型
一、數字
基本數據類型經常使用功能
int（整型）
在32位機器上，整數的位數爲32位，取值範圍爲-2**31～2**31-1，即-2147483648～2147483647
在64位系統上，整數的位數爲64位，取值範圍爲-2**63～2**63-1，即-9223372036854775808～9223372036854775807
在64位系統上，整數的位數爲64位，取值範圍爲-2**63～2**63-1，即-9223372036854775808～9223372036854775807
a . 示例
s1 = 123
b2 = 789
print(s1 + b2 )
print(s1.__add__(b2))
b. 示例
獲取可表示的二進制最短數位
s1 = 4 # 000000100
test = s1.bit_length()
pritn(test)
str :
class str(basestring):
""" str(object='') -> string Return a nice string representation of the object. If the argument is a string, the return value is the same object. """ def capitalize(self): """ 首字母變大寫 """ """ S.capitalize() -> string Return a copy of the string S with only its first character capitalized. """ return ""
示例：capitalize 方法
a1 = "hello"
test = a1.capitalize()
print(test)
def center(self, width, fillchar=None): """ 內容居中，width：總長度；fillchar：空白處填充內容，默認無 """ """ S.center(width[, fillchar]) -> string Return S centered in a string of length width. Padding is done using the specified fill character (default is a space) """ return ""
示例：center方法
a1 = "hello"
test = a1.center(100, " ")或者 = a1.center(50,"_")
print(test)
def count(self, sub, start=None, end=None): """ 子序列個數 """ """ 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
示例：count方法
a1 = "hello is cmake or so ccoll"
test = a1.count("o") #或：
test = a1.count("o" , 0 ,50)
print(test)
def endswith(self, suffix, start=None, end=None): """ 是否以 xxx 結束 """ """ S.endswith(suffix[, start[, end]]) -> bool Return True if S ends with the specified suffix, False otherwise. 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
示例：endswith方法
a1 = "hello"
test = "o"
print(a1.endswith(test))
print(a1.endswit("o", 0, 2)) # 獲取字符串裏大於等於0的位置，小於2的位置
def expandtabs(self, tabsize=None): """ 將tab轉換成空格，默認一個tab轉換成8個空格 """ """ S.expandtabs([tabsize]) -> string 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. """ return ""
示例：expandtabs方法
a1 = "user\tmail\tpwd\nchen\taba@q.com\t123456\nwang\tabb@q.com\t123456\nxiao\tabc@q.com\t123456"
print(a1)
print(a1.expandtabs(20))
def find(self, sub, start=None, end=None): """ 尋找子序列位置，若是沒找到，返回 -1 """ """ S.find(sub [,start [,end]]) -> int Return the lowest 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
示例：find方法
a1 = "ccy hello"
print(a1.find("p"))
def format(*args, **kwargs): # known special case of str.format """ 字符串格式化，動態參數，將函數式編程時細說 """ """ S.format(*args, **kwargs) -> string Return a formatted version of S, using substitutions from args and kwargs. The substitutions are identified by braces ('{' and '}'). """ pass
示例:format 方法
a1 = "hello {0}, age{1}"
print(a1)
print(a1.format("hello",20))
def index(self, sub, start=None, end=None): """ 子序列位置，若是沒找到，報錯 """ S.index(sub [,start [,end]]) -> int Like S.find() but raise ValueError when the substring is not found. """ return 0
示例： index 方法
a1 = "hello bugs"
print(a1.index("k"))
def isalnum(self): """ 是不是字母和數字 """ """ S.isalnum() -> bool Return True if all characters in S are alphanumeric and there is at least one character in S, False otherwise. """ return False def isalpha(self): """ 是不是字母 """ """ 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 isdigit(self): """ 是不是數字 """ """ 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 islower(self): """ 是否小寫 """ """ S.islower() -> bool Return True if all cased characters in S are lowercase and there is at least one cased character in S, False otherwise. """ return False def isspace(self): """ S.isspace() -> bool Return True if all characters in S are whitespace and there is at least one character in S, False otherwise. """ return False def istitle(self): """ S.istitle() -> bool Return True if S is a titlecased string and there is at least one character in S, i.e. uppercase characters may only follow uncased characters and lowercase characters only cased ones. Return False otherwise. """ return False def isupper(self): """ S.isupper() -> bool Return True if all cased characters in S are uppercase and there is at least one cased character in S, False otherwise. """ return False def join(self, iterable): """ 鏈接 """ """ S.join(iterable) -> string Return a string which is the concatenation of the strings in the iterable. The separator between elements is S. """ return ""
示例： join 方法
a1 = ["hello","word","cccy"] #列表 或：
a1 = ("hello","word","cccy") #元組
s = "",join(a1)
print(s)
def ljust(self, width, fillchar=None):
""" 內容左對齊，右側填充 """ """ S.ljust(width[, fillchar]) -> string Return S left-justified in a string of length width. Padding is done using the specified fill character (default is a space). """ return ""
示例: ljust 方法
a1 = "This is example.......tree"
test = a1.ljust(50, "_") #ljust()將字符串左對齊右側填充
print(test)
test2 = a1.rjust(50, "_") #rjust()將字符串右對齊左側填充
print(test2)
def lstrip(self, chars=None):
""" 移除左側空白 """ """ S.lstrip([chars]) -> string or unicode Return a copy of the string S with leading whitespace removed. If chars is given and not None, remove characters in chars instead. If chars is unicode, S will be converted to unicode before stripping """ return ""
示例：lstrip, rstrip,strip 方法
a1 = " hello"
newa = a1.lstrip() #移除左側空白
print(newa)
a2 = "hello "
newb = a2.rstrip（）#移除右側空白
print (newb)
a3 = " hello "
newc = a3.strip() #移除兩段空白
print(newc)
def partition(self, sep):
""" 分割，前，中，後三部分 """ """ 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
示例：partition 方法
a1 = "cccy AS alex"
test = a1.partition("AS")
#("cccy", "AS", "alex") #元組類型
print(test)
def replace(self, old, new, count=None): """ 替換 """ """ S.replace(old, new[, count]) -> string Return a copy of string 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 ""
示例：replace 方法
a1 = "cccd sd abse"
text = a1.replace("sd","FG", 2)
print(text)
def rfind(self, sub, start=None, end=None):
""" 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 def rindex(self, sub, start=None, end=None): """ S.rindex(sub [,start [,end]]) -> int Like S.rfind() but raise ValueError when the substring is not found. """ return 0 def rjust(self, width, fillchar=None): """ S.rjust(width[, fillchar]) -> string Return S right-justified in a string of length width. Padding is done using the specified fill character (default is a space) """ return "" def rpartition(self, sep): """ 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 def rsplit(self, sep=None, maxsplit=None): """ S.rsplit([sep [,maxsplit]]) -> list of strings Return a list of the words in the string S, using sep as the delimiter string, starting at the end of the string and working to the front. If maxsplit is given, at most maxsplit splits are done. If sep is not specified or is None, any whitespace string is a separator. """ return [] def rstrip(self, chars=None): """ S.rstrip([chars]) -> string or unicode Return a copy of the string S with trailing whitespace removed. If chars is given and not None, remove characters in chars instead. If chars is unicode, S will be converted to unicode before stripping """ return "" def split(self, sep=None, maxsplit=None): """ 分割， maxsplit最多分割幾回 """ """ S.split([sep [,maxsplit]]) -> list of strings Return a list of the words in the string 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 [] def splitlines(self, keepends=False): """ 根據換行分割 """ """ S.splitlines(keepends=False) -> 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 [] def startswith(self, prefix, start=None, end=None): """ 是否起始 """ """ 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 def strip(self, chars=None): """ 移除兩段空白 """ """ S.strip([chars]) -> string or unicode 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. If chars is unicode, S will be converted to unicode before stripping """ return "" def swapcase(self): """ 大寫變小寫，小寫變大寫 """ """ S.swapcase() -> string Return a copy of the string S with uppercase characters converted to lowercase and vice versa. """ return "" def title(self): """ S.title() -> string Return a titlecased version of S, i.e. words start with uppercase characters, all remaining cased characters have lowercase. """ return "" def translate(self, table, deletechars=None): """ 轉換，須要先作一個對應表，最後一個表示刪除字符集合 intab = "aeiou" outtab = "12345" trantab = maketrans(intab, outtab) str = "this is string example....wow!!!" print str.translate(trantab, 'xm') """ """ S.translate(table [,deletechars]) -> string Return a copy of the string S, where all characters occurring in the optional argument deletechars are removed, and the remaining characters have been mapped through the given translation table, which must be a string of length 256 or None. If the table argument is None, no translation is applied and the operation simply removes the characters in deletechars. """ return "" def upper(self): """ S.upper() -> string Return a copy of the string S converted to uppercase. """ return "" def zfill(self, width): """方法返回指定長度的字符串，原字符串右對齊，前面填充0。""" """ S.zfill(width) -> string Pad a numeric string S with zeros on the left, to fill a field of the specified width. The string S is never truncated. """ return "" def _formatter_field_name_split(self, *args, **kwargs): # real signature unknown pass def _formatter_parser(self, *args, **kwargs): # real signature unknown pass def __add__(self, y): """ x.__add__(y) <==> x+y """ pass def __contains__(self, y): """ x.__contains__(y) <==> y in x """ pass def __eq__(self, y): """ x.__eq__(y) <==> x==y """ pass def __format__(self, format_spec): """ S.__format__(format_spec) -> string Return a formatted version of S as described by format_spec. """ return "" def __getattribute__(self, name): """ x.__getattribute__('name') <==> x.name """ pass def __getitem__(self, y): """ x.__getitem__(y) <==> x[y] """ pass def __getnewargs__(self, *args, **kwargs): # real signature unknown pass def __getslice__(self, i, j): """ x.__getslice__(i, j) <==> x[i:j] Use of negative indices is not supported.