哲学原理和失眠说再见

by admin on 2018年10月17日

  在python中置了重重函数或者类,比如:int,str,list,tuple,等。当然为足以由建函数,这个在后文讨论。原理如下:

哎呀~以前一直觉得失眠主要是投机调整心态才能够哼,可是一直还尚未!有!用!!后来于网上多检查之后,发现了部分超级有用之措施,从原先三四点还和辗转反侧靠吃助眠药睡觉,到近年来片龙睡眠得深看好死看好,感觉硬极了! 

  哲学原理 1

一致、睡眠的五单等级(科普ing~请叫我到先生!哈哈)

  其实python中之近乎以及章程十分非常多,这里只是以点带面,提供一个上之章程。

其次、呼吸对睡眠的机要(对本人可怜使得)

  (一)int

老三、冥想(也对,情绪激动的时呢足以尝试)

以举例

季、大量之动(出汗水-热水澡-睡觉,想想都舒服哇~)

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

age = -19                   #其实是执行了一个__init__的过程。
print (type(age))              #打印age的类型
age = int(age)
re =  age.__float__()                   #将age的类型变成浮点类型,注,本来是int类型。
print(type(re))                         #打印re的类型
reslutd = age.__abs__()                 #绝对值.(-19)=19。    <===>...reslutd=abs(age)
reslut = reslutd.__divmod__(3)          #divmod得出商和余数,19/4。在写扉页的时候会用到。<===>...reslutd=divmod(age)
reslut_fan = reslutd.__rdivmod__(4)     #反向求商和余数。4/19
print(reslutd,reslut_fan,reslut)

#结果
'''
<class 'int'>
<class 'float'>
19 (0, 4) (6, 1)
'''

五、一些建议(来自失眠的总人口)

  按停Ctrl,点击int,可以当builtins模块中见到int成员,其中int成员里大部分且是牵动下划线的,这同样好像的效用大多是经内置方法就是好直接执行(例子参考上面abs,divmod和下文中add),请看:

一致、睡眠的五只级次睡眠的通过程:

欠睡了,于是熄灯,上床,盖好舒服的被,来回折腾几糟糕,终于找到一个足够满意的相,闭上眼睛。在始发之几乎分钟里你有倦意,却百般清醒,随意得想方部分事情。慢慢得你的琢磨进一步不着边际,身体也愈放松。不知不觉中,你进睡眠的率先个等级。

第一独号可以称之为“昏昏欲睡”,这个阶段你不要真正的在睡觉。你的人进一步放松,肌肉的乱感慢慢消失,呼吸和心跳逐渐变缓,体温下降。你的觉察就不再连贯,不再醒来。

没完没了几分钟之后,你见面跻身睡眠的亚独号,这是独突如其来的进程,你会以全没预知的情形下突然进来睡眠。这同样等是实在的睡眠。你的身心更加平静,和外界的链接逐步断开,却不曾完全断开。所以亚路睡眠比较浅,容易被外边的事态惊醒。

一半时到四十五分钟以后,你见面跻身更甚的睡觉中,也就是第3、4路的上床。在这有限段子日子中君的脑波会变得挺缓慢,通常咱们遂该也深度睡眠。在当下段时间里,我们的生理活动、氧气消耗、心率以及血压还见面落到平等上被之最低水平。处在深度睡眠中的食指以及外侧的链接几乎全断开,很为难被唤起。如果你在马上段日子里让狂暴唤醒,很可能会见发没有动向,眩晕,在一段时间内啊都想不起来。

于持续45分钟左右底吃水睡眠后,我们见面短暂得返回睡眠的次等,紧接着会跻身梦境时,也就是是第五级,科学里通常称之为REM(rapid
eye
movement)。这是甚神奇的一个流,一个丁于REM时间外会进去外一样种植发现,产生大量的梦幻,身体的外向程度还于苏时常还而后来居上,我们的体温、心率、血压会换得深不对头,脑波的转移十分迅速,体内的能量消耗很快,这种状态特别相近我们清醒时常的状态。很风趣的是于REM时期男人和夫人的生殖器官都见面为兴奋而充血,这并无是盖做梦。因为在当下无异于阶段人们的大脑与身体还充分活跃,所以非常轻醒过来。

眼看几个等级一共会频频大约90分钟,睡眠健康的丁于平等夜间会晤管这90分钟进行4~6个巡回。各等级持续时间所占有比重为,第1等:5%;第2级:50%;第3、4级(深度睡眠):20%;第5号(REM):25%。在前半夜深度睡眠会更多一些,后半夜间睡梦时会见比多,所以后半夜人们人再次爱醒。

哲学原理 2哲学原理 3

其次、呼吸对睡眠的关键

在某种程度上失眠源自大脑的缺氧。紧张焦躁的心气,过多苦,糟糕的体质,不通风的环境等等都见面造成大脑缺氧,从而出现失眠。让我们注意以下事实:

当您心慌意乱、害怕、焦虑的当儿,呼吸会变得短促,浅薄。在这些时候常见会以为什么还没法做好。

当你用心思考的时段,比如考试受到,呼吸会很仓促。考试之后起身会认为大脑缺氧,疲劳。

一个体质较差之人呼吸会非常急匆匆,气短。(中枪哇~)

因此,在你无法入眠的时段,注意自己之深呼吸,那时候你的深呼吸一定死浅、短、急促。这种短促的呼吸让肺部没法充分工作,会造成你的大脑氧气不足,于是无法镇静自己的神经,导致失眠

调动协调之深呼吸

您可小心熟睡中的众人,他们之呼吸会非常沉重,悠长,富有节奏。而在日常生活中,人们对肺部的采取很不充分,每次呼吸大概只有所以到1/3之肺部容量,甚至还不见。再长城市中之氧质量无愈,使得绝大多数丁老处在氧气不足之状态。在缺氧状态下容易紧张、焦虑,失眠也就算欠缺为惊诧。

那当入睡过程遭到,想如果避免失眠,最要紧之就算是调动好的深呼吸,使呼吸深长而且出韵律,并保障这种呼吸的状态。每当你感到无法入睡时,就将注意力集中到温馨的深呼吸上。或许正好开头之上你晤面异常不习惯这种深长的透气,那是盖若的肌肉无法适应。但是保持一段时间,就可知感觉到大当然。一旦切换到这种健康之透气法,你的干着急和心烦意乱情绪会立刻博得化解。保持这种呼吸,就可知可怜快入睡。

def __abs__(self, *args, **kwargs): # real signature unknown
    """ abs(self) """
    pass
#取绝对值

def __add__(self, *args, **kwargs): # real signature unknown
    """ Return self+value. """
    pass
#相加,print(1+1)其实就是调用了“int”中内置的__add__这个函数,所以可以直接执行。但过程依然是:创建对象,调用方法,得到结果。

def __and__(self, *args, **kwargs): # real signature unknown
    """ Return self&value. """
    pass
#融合
def __bool__(self, *args, **kwargs): # real signature unknown
    """ self != 0 """
    pass
#变成波尔类型

def __pow__(self, *args, **kwargs): # real signature unknown
    """ Return pow(self, value, mod). """
    pass
#取指数

....

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
#返回用最少多少位可以表示当前数字
#举例:
a= 59
result = a.bit_length()
print(result)
#结果
6

三、冥想

冥想对失眠的治病功效远明显。失眠人群最怕的是压力以及浮动,而由此短日的冥想能迅速消除这些压力,让好之神经很快放松下来。但是冥想是看似简单也特别有技术的相同件事,所以初家往往会产出杂念丛生无法静心的场面,往往更加想越滥,越做进一步着急。我在初学的早晚啊会现出这些状况,但是通过不断的雕刻和查看体会至有些技术,分享给大家。

1.失眠的情人等可以于睡前召开冥想,做到好心完全平静下来,感觉挺舒畅的早晚还夺睡。如果半夜间醒来在20分钟内无法入眠,起身做冥想,直到好的心气了平静与放宽下来,再回去睡觉。我虽是这样做的,每次总能够入眠。

2.冥怀念的人工呼吸太好能使用腹式呼吸,就是奶不动,吸气时腹部隆起,呼气时腹部下陷。这样的人工呼吸法能还管用的收纳氧,也再易排除体内废气。多练习几次于就是会掌握。呼吸的效率肯定要慢,要没,要长,多将注意力集中在温馨的深呼吸上,时刻去调整,有助于消除杂念。呼气和吸烟之间停顿一点日子,在就段时外再也排除杂念,准备下一个松的地位,准备生一样潮呼气或抽烟。

3.比方你正展开完毕繁重的心力累,或者情绪坏感动,很紧张。这时候坐下冥想时多次很为难松。可以优先抽出十几分钟之年月举行片体力上的移动,伸展运动、力量锻炼、瑜伽等等都特别好。之后再度拓展冥想。

4.松的上要从头到脚,你会发觉好不便连续的放松,你说到底会失掉思把其它的政工,但是没关系,重新归来就算哼。要专注去放松自己的目、舌头,往往是随即点儿独地方被你乱。

5.千万非可以刻意、努力去放松。一切顺其自然,随着呼气放松每个部位。只有把一身都放松下来,大脑才会失掉放松。大脑放松下来的风味之一是额头彻底放松了,而在您思考要乱之时光前额是不可能放松的。

6.当你闹十分麻烦去除的私心杂念时。吸一口气,站于你的通想法之外,凝视它,把镜头拉远,你慢慢看到任何城市,整个国家,整个地球。当您在于一体宇宙中不时,就会见意识而的每个想法都是那么的无所谓,这时候你就算可知自在得管它们还呼出。(听起来如在传教~但尝试后认为既然有趣又可行)

7.于头部及足部日益放松而的肌肉,每次呼气的时节进行放宽,这促进打破思想压力和身体紧张中的联系。从您的脑门儿开始,吸气时咀嚼压力,当呼气时尽可能吐生压力,感觉部位放松、变软、下没。身体余产局部逐个为底,从眼睛,咬肌,脖子,肩膀,手臂,手掌,胸口,上背,中腰和中腹部,下背着,腹部,盆骨,臀部,大腿,小腿,最后到足部。(以前练瑜伽也时有发生就同样步,以前总认为怪折腾笑,现在认为以前的和谐真幼稚啊~)

8.怀着积极的神态,不用失去思自己是否做的够好,当其他杂念冒出头脑时,简单告诉自己”好吧”,然后回自己的深呼吸着错过。当您连几健全之后,就会发现自己的衷心与设法来了森别,自己的满心更坦然,睡得也再也好。

int成员

季、大量的移动

倒不仅对睡觉有的不安中,对另外款式之紧张且发生因此。运动克服紧张的法则及另外的措施有所不同,它是一样种植人和旺盛及之放。但是同泡酒吧,蹦迪或者大声吼歌不同,那些方式属于同一种植逃避,暂时通过平等种植纯粹的鼓舞来逃避紧张心态,当这些刺激逝去之后,一切恢复原样。而移动不仅释放焦虑的情绪,还可调节体温,增强信心,通过战胜伤痛获得心灵之安静,是破除紧张见效最抢的方。运动不仅会脱紧张,还好让投机清醒,如果白天感到挺疲劳,可以通过移动来让自己清醒过来,摆脱昏昏欲睡的状态。每天都坚持走,可以十分管用的铲除紧张之活状态。

大气底移动是依赖持续至少半只小时以上的有氧运动,会有汗水,让人比较疲劳。对协调的话比较有难度来挑战的走比适当,瑜伽,长跑,游泳都死好。短日的剧烈运动一样可以解决紧张,比如明确的舒张,或者部分力量型的移动。

 

五、一些提议

1.“顺其自然”心态。睡得在就是上床,“躺下虽是缓”,我之活佛这样说的。使劲想睡觉在见面弄巧成拙。

2.早起及时间风起云涌,不管夜里睡觉怎样。

3.千万毫无因失眠去举行另外决定。比如说为失眠了公而辞职在家休息,比如说你失眠了于是睡得还早一点……这些决定都见面受你的失眠更加糟糕。去比导致自己失眠的根本原因,而未是吃失眠牵着鼻子走。

4.广大失眠的食指睡在铺上便开操心还未是今天为会见失眠所以非常担忧就是会内心跳加速浑身发热腹式呼吸真的凡一个不行好的章程它帮忙了自我过来自己之心思而我慢慢放松在联络腹式呼吸一段时间后就见面日趋地发现自己在不自觉的行使腹式呼吸逐渐地就算着了

5.领你的忧虑忍受而的焦虑而会逐年的学会观察自己的忧患失眠不是对准君的处!!!相反的为上天容易您期望你有一个重复正常又积极又平添的存为自之亲身经验就是种种我已比失眠之前又努力再明了感恩早由开协调喜好的作业上做运动就是本人失眠之前都未曾感念过的正常化在方法(虽然这人写字没有标点,看起格外累的,可是看了好激动~)

6.超人的恶性循环:失眠–焦虑–紧张–失眠又重。所以克服紧张就是是错开打破这恶性循环。这和克服失眠的方本质上是一律的:改善好的一言一行与想方设法。行动是医失眠的要害。

7.了一个日增而活跃的白昼,就会被你在睡的时光有疲倦。如果睡觉的时还是不困,依然束手无策入眠,那就是起累上或者工作,直到好疲倦了还回来床上睡。记住,看言情小说,看无聊的电视剧这种工作,不会见受您慵懒。

意在大家都能歇得香香的呐~~~

一部分参考来源:

http://www.douban.com/group/hellosleep/

http://hellosleep.net/

(二)str

先来只例题

#字符串。str如‘张洪震’‘zhang’。举例:
name = 'zhang'
name = str('zhang')                          #str执行时其本质是执行的.__init__方法.按住Ctrl,点击“str” ,查看有哪些成员
print(type(name))                            #tpye.快速获取类
print(dir(name))                             #dir.快速获取这个类里面有哪些成员
a = name.__contains__('ang')                 #a<=>b,a和b其实是一样的。
b = 'zh' in name
print(a,b)

#结果:
'''
<class 'str'>
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
True True

来拘禁下其他的积极分子:

哲学原理 4哲学原理 5

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

a = 'abc'
def capitalize(self): # real signature unknown; restored from __doc__
        """
        S.capitalize() -> str
       #让第一个字母大写
        """
        return ""
a1 = a.capitalize()
print(a1)
#结果
#Abc

def center(self, width, fillchar=None): # real signature unknown; restored from __doc__
        #width宽度;fillchar=None,填充字符,默认为空格
        """
        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 ""
a2 = a.center(10)                           #让a这个字符串宽度为10.且abc位于中央。
print(a2)
#   abc
a3 = a.center(10,'@')              #以@为填充符。
print(a3)
#@@@abc@@@@

def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """
        #统计子序列出现的次数。
        #sub附属的,起始位置,结束为止
        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
a4 = a.count('a',0,2)                     #计算从0-2之间有几个a。
print(a4)
#1

def encode(self, encoding='utf-8', errors='strict'): # real signature unknown; restored from __doc__
    """
    #转码,encoding是编码方式;默认转成utf-8。errors是错误处理方式。
    S.encode(encoding='utf-8', errors='strict') -> bytes
    """
    return b""                            #返回为b"",就是以b开头。
A = '张洪震'
a5 = A.encode('gbk',errors='ignore')    #转成gbk编码,忽略错误。注:其实内部还是从utf-8转为Unicode,再从Unicode转为gbk。
print(a5)
#b'\xd5\xc5\xba\xe9\xd5\xf0'

def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
    """
    S.endswith(suffix[, start[, end]]) -> bool
    #suffix后缀,
    suffix can also be a tuple of strings to try.#后缀也可以是一个元组。
    """
    return False                #返回正误
a6 = a.endswith('c',0,3)                   #这里注意一下,是0<=suffix position.<3,
#a6 = a.endswith('c',0,2),这样写会报错。
print(a6)
#True

def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__
        """
        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 expandtabs(self, tabsize=8): # real signature unknown; restored from __doc__
        """
        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.
        #返回一个用空格代替tab键的副本。
        """
        return ""
B = 'zhan   g'
b7 = B.expandtabs()
print(b7)
#zhan   g

def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """
        #查找出sub所在的位置。
        S.find(sub[, start[, end]]) -> int
        Return -1 on failure.#如果失败的话返回-1.
        """
        return 0
a8 =a.find('c',0,3)                         #在0-2的位置找c。
a9 =a.index('b')                            #index和find都是找,index找不到的话会直接报错。
print(a8,a9)
#2 1

def format(*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.
        返回一个格式化的字符串,用替换的来自于传参。
        The substitutions are identified by braces ('{' and '}').
        被替换的东西用{}来定义
        """
        pass
C ='zhen,{0},{1}'
a10 = C.format('是四个字母','对')            #传参为“是四个字母”
print(a10)
#zhen,是四个字母,对
D ='zhen,{dd},{ddd}'
a10 = D.format(dd='是四个字母',ddd='对')     #做一个动态对应
print(a10)
#zhen,是四个字母,对

#以is开头的大都是判断,举一个例子
def isalnum(self):               # 判断是否是文字数字
        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.元素之间的分隔符是S.。
        """
        return ""
E=['ni hao','zhang','chi le ma']          #定义一个列表
a11= ",".join(E)                          #让“E”中的字符串以“,”为分割符相连。
print(a11)
#ni hao,zhang,chi le ma

def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__
    """
    S.ljust(width[, fillchar]) -> str
    左对齐。参数为宽度,填充字段.默认为空
    """
    return ""

def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__
    """
    S.rjust(width[, fillchar]) -> str
    右对齐。参数为宽度,填充字段,默认为空
    """
    return ""
F = 'abc'
a12=F.ljust(7,'#')              #让F的宽度为7个字符,如果不够7个,那么在字符串的右边填充上“#”把字符串“挤”至左对齐。
print(a12)
a13=F.rjust(6,'$')              #让F的宽度为6个字符,如果不够6个,那么在字符串的左边填充上“#”把字符串“挤”至右对齐。
print(a13)
#结果
'''
abc####
$$$abc
'''

def lower(self): # real signature unknown; restored from __doc__
        """
        S.lower() -> str
         Return a copy of the string S converted to lowercase.
       返回一个字符串的小写副本。
        """
        return ""
def upper(self): # real signature unknown; restored from __doc__
        """
        S.upper() -> str
        大写
        Return a copy of S converted to uppercase.
        """
        return ""

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 ""
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.
        返回一个去掉字符串的开头空格的副本
        如果给定字符而不是空的,则删除给定字符。
        """
        return ""
a14=a.lstrip('a')
print(a14)
def rstrip(self, chars=None): # real signature unknown; restored from __doc__
        """
        S.rstrip([chars]) -> str
        Return a copy of the string S with trailing whitespace removed.
        If chars is given and not None, remove characters in chars instead.
        返回一个去掉字符串的结尾空格的副本
        如果给定字符而不是空的,则删除给定字符。
        """
        return ""
a15=a.rstrip('c')
print(a15)

def partition(self, sep): # real signature unknown; restored from __doc__
        """
        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.
        在字符串中搜索分隔符,并返回它前面的部分、分隔符本身和后面的部分。如果找不到分隔符,返回s和两个空字符串。
        """
        pass
a16= a.partition('b')            #以b为分隔符
print(a16)
#('a', 'b', 'c')
a17= a.partition('d')            #以d为分割符
print(a17)
#('abc', '', '')

def replace(self, old, new, count=None): # real signature unknown; restored from __doc__
        """
        S.replace(old, new[, count]) -> str
        old replaced by new.  If the optional argument count is
        given, only the first count occurrences are replaced.
        """
        return ""
h='aaaaaaa'
h1= h.replace('a','b',3)          #用b替换a,个数为3
h2=h.replace('a','9',2)
print(h1,h2)
#bbbaaaa 99aaaaa

def split(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
        """
        S.split(sep=None, maxsplit=-1) -> list of strings
        分割。
        """
i='zhang hong z hen'
i1=i.split('h',2)              #指定h为分隔符,i中有3个h,指定最大为2个,所以,只有两个作为分割符了
i2=i.split()                 #没有指定,则以空格为分割符并删除空格
print(i1,i2)
#['z', 'ang ', 'ong z hen'] ['zhang', 'hong', 'z', 'hen']


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 ""


def title(self): # real signature unknown; restored from __doc__
        """
        S.title() -> str

        Return a titlecased version of S, i.e. words start with title case
        characters, all remaining cased characters have lower case.
        """
        return ""

str其他成员

  

   通过者可以见见其实python的诠释很清晰简洁,真的难懂的语可经过翻软件翻译下,一般景象下是得看懂的。

(三)list列表

如:[‘zhang’]、[11,’hong’,’zhen’]

哲学原理 6哲学原理 7

class list(object):
    """
    list() -> new empty list
    list(iterable) -> new list initialized from iterable's items
    """
    def append(self, p_object): # real signature unknown; restored from __doc__
        """ L.append(object) -> None -- append object to end """        #从列表末尾加入元素
        pass

    def clear(self): # real signature unknown; restored from __doc__
        """ L.clear() -> None -- remove all items from L """           #清除所有
        pass

    def copy(self): # real signature unknown; restored from __doc__
        """ L.copy() -> list -- a shallow copy of L """              #浅拷贝
        return []

    def count(self, value): # real signature unknown; restored from __doc__
        """ L.count(value) -> integer -- return number of occurrences of value """
                                              #计数
        return 0

    def extend(self, iterable): # real signature unknown; restored from __doc__
        """ L.extend(iterable) -> None -- extend list by appending elements from the iterable """  
                                               #扩展,将新列表元素加到老列表中

        pass                                      

    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

    def insert(self, index, p_object): # real signature unknown; restored from __doc__
        """ L.insert(index, object) -- insert object before index """      #指定位置插入元素
        pass

    def pop(self, index=None): # real signature unknown; restored from __doc__
        """
        L.pop([index]) -> item -- remove and return item at index (default last).
        Raises IndexError if list is empty or index is out of range.       #移除,参数为指定位置
        """
        pass

    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

    def reverse(self): # real signature unknown; restored from __doc__
        """ L.reverse() -- reverse *IN PLACE* """                   #反转,即倒序。
        pass

    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

list成员

 

 (四)tuple元组

如:(11,22,)(‘zhang’,[11,22,33],)

哲学原理 8哲学原理 9

class tuple(object):
    """
    tuple() -> empty tuple
    tuple(iterable) -> tuple initialized from iterable's items

    If the argument is a tuple, the return value is the same object.
    """
    def count(self, value): # real signature unknown; restored from __doc__
        """ T.count(value) -> integer -- return number of occurrences of value """#计数
        return 0

    def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
        """
        T.index(value, [start, [stop]]) -> integer -- return first index of value.#返回一个索引
        Raises ValueError if the value is not present.
        """
        return 0
    #例:
    a=(('zhang'),[11,22,33],)
    re=a.index('zhang')
    print(type(a),re)

    #<class 'tuple'> 0

tuple成员

 

 (五)dict字典

如:{‘张’:’shuai’,’host’:’Cmelo.com’,’123′:’abc’}

使用:

name1=[11,22,33,44,55,66,77,88,99]
name2=[1,2,3,4,5,6,7,8,9]
dict[‘k1’]=name1 #<=>dic=dict(k1=name1)
dict[‘k2’]=name2 #<=>dic2=dict(k2=name2)

哲学原理 10哲学原理 11

dict

dd={'张':'shuai','host':'Cmelo.com','123':'abc'}

class dict(object):
    """
    dict() -> new empty dictionary
    dict(mapping) -> new dictionary initialized from a mapping object's
        (key, value) pairs
    dict(iterable) -> new dictionary initialized as if via:
        d = {}
        for k, v in iterable:
            d[k] = v
    dict(**kwargs) -> new dictionary initialized with the name=value pairs
        in the keyword argument list.  For example:  dict(one=1, two=2)
    """
    def clear(self): # real signature unknown; restored from __doc__
        """ D.clear() -> None.  Remove all items from D. """
        pass

    def copy(self): # real signature unknown; restored from __doc__
        """ D.copy() -> a shallow copy of D """
        pass

    @staticmethod # known case
    def fromkeys(*args, **kwargs): # real signature unknown
        """ Returns a new dict with keys from iterable and values equal to value. """
        pass

    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. 如果key在D中就是key,否则就是设置的d。d默认是空"""
        pass
    #例
    dd={'张':'shuai','host':'Cmelo.com','123':'abc'}
    kk= dd.get('li','sorry,meiyouzhaodao')
    print(kk)
    #sorry,meiyouzhaodao


    def items(self): # real signature unknown; restored from __doc__
        """ D.items() -> a set-like object providing a view on D's items 输出所有的字典对儿"""
        pass

    def keys(self): # real signature unknown; restored from __doc__
        """ D.keys() -> a set-like object providing a view on D's keys 输出所有的key值"""
        pass
    def values(self): # real signature unknown; restored from __doc__
        """ D.values() -> an object providing a view on D's values 输出所有的value值。"""
        pass

    def pop(self, k, d=None): # real signature unknown; restored from __doc__
        """
        D.pop(k[,d]) -> v, remove specified key and return the corresponding value.给定k值,删除相应的value
        If key is not found, d is returned if given, otherwise KeyError is raised如果key没有找到,如果给了d的话d会输出。否则,报错,
        """
        pass
    #例:
    dd={'张':'shuai','host':'Cmelo.com','123':'abc'}
    aa= dd.pop('li','sorry,meiyouzhaodao')
    bb=dd.pop()
    print(aa,bb)
    #sorry,meiyouzhaodao
    #bb=dd.pop()
    #TypeError: pop expected at least 1 arguments, got 0

    def popitem(self): # real signature unknown; restored from __doc__
        """
        D.popitem() -> (k, v), remove and return some (key, value) pair as a
        2-tuple; but raise KeyError if D is empty.                            #随机删除一个对儿,如果参数是空的话会报错
        """
        pass

    def setdefault(self, k, d=None): # real signature unknown; restored from __doc__
        """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D   给设置一个默认值"""
        pass

    def update(self, E=None, **F): # known special case of dict.update
        """
        D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
        If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
        If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
        In either case, this is followed by: for k in F:  D[k] = F[k]
        """
        pass
    def __contains__(self, *args, **kwargs): # real signature unknown
        """ True if D has a key k, else False. """
        pass

    def __delitem__(self, *args, **kwargs): # real signature unknown
        """ Delete self[key]. """
        pass

    def __eq__(self, *args, **kwargs): # real signature unknown
        """ Return self==value. """
        pass

    def __getattribute__(self, *args, **kwargs): # real signature unknown
        """ Return getattr(self, name). """
        pass

    def __getitem__(self, y): # real signature unknown; restored from __doc__
        """ x.__getitem__(y) <==> x[y] """
        pass

    def __ge__(self, *args, **kwargs): # real signature unknown
        """ Return self>=value. """
        pass

    def __gt__(self, *args, **kwargs): # real signature unknown
        """ Return self>value. """
        pass

    def __init__(self, seq=None, **kwargs): # known special case of dict.__init__
        """
        dict() -> new empty dictionary
        dict(mapping) -> new dictionary initialized from a mapping object's
            (key, value) pairs
        dict(iterable) -> new dictionary initialized as if via:
            d = {}
            for k, v in iterable:
                d[k] = v
        dict(**kwargs) -> new dictionary initialized with the name=value pairs
            in the keyword argument list.  For example:  dict(one=1, two=2)
        # (copied from class doc)
        """
        pass

    def __iter__(self, *args, **kwargs): # real signature unknown
        """ Implement iter(self). """
        pass

    def __len__(self, *args, **kwargs): # real signature unknown
        """ Return len(self). """
        pass

    def __le__(self, *args, **kwargs): # real signature unknown
        """ Return self<=value. """
        pass

    def __lt__(self, *args, **kwargs): # real signature unknown
        """ Return self<value. """
        pass

    @staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

    def __ne__(self, *args, **kwargs): # real signature unknown
        """ Return self!=value. """
        pass

    def __repr__(self, *args, **kwargs): # real signature unknown
        """ Return repr(self). """
        pass

    def __setitem__(self, *args, **kwargs): # real signature unknown
        """ Set self[key] to value. """
        pass

    def __sizeof__(self): # real signature unknown; restored from __doc__
        """ D.__sizeof__() -> size of D in memory, in bytes """
        pass

    __hash__ = None

dict成员

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图