python常用知识梳理(必看篇)

接触python已有一段时间了,下面针对python基础知识的使用做一完整梳理:

1)避免‘\n'等特殊字符的两种方式:

a)利用转义字符‘\'
b)利用原始字符‘r' print r'c:\now'

2)单行注释,使用一个#,如:

#hello Python
多行注释,使用三个单引号(或三个双引号),如:
'''hello python
hello world'''
或
"""hello python
hello world"""
另外跨越多行的字符串。也可以使用三个单引号或三个双引号,如:
'''......'''
或者
"""......"""

3)字符串中嵌入双引号等特殊符号

a)利用转义字符‘\'
b)使用单引号括起这个字符串。print ('i l"o"ve fis.com')

4)条件分支:

if condition:
     条件为真执行的操作
  else:
     条件为假执行的操作 

  if condition:
     action
  elif condition:
     action
  else:
    action 

python可以有效避免“悬挂else”(if else对应关系出错)
条件表达式(三元操作符)
    small = x if x<y else y
    如果x<y ,small=x.否则small=y
断言assert:当这个关键字后面的条件为假,程序自动崩溃并抛出异常
   assert 3>4
   可以利用他置入检查点

5)while条件:

条件为真执行的操作 

for 目标 in 表达式:
循环体
 例:favorite='fishc'
    for i in favorite:
       print(i,end='') 

range([start,] stop[,step=1])
生成一个从start参数的值到stop参数值的数字序列 

break:终止当前循环体。跳到外层程序
continue:终止本轮循环,开始下一轮循环(if condition true)

6)and逻辑操作符可以将任意表达式连接在一起,并得到一个布尔类型值

7)引入外援:

a)random模块
b)randint(),返回一个随机的整数
import random 或 from random import randint()
secret=random.randint(1,10)

8)python数据类型

a)数值类型:整型、布尔类型、浮点型、e记法(1.5e10)
b)类型转换:
   int()转换为整数
   str()转换为字符串
   float()转换为浮点数
c)获取关于类型的信息:
   type()函数
    a=520
    type(a)
   isinstance()函数
    a=12
    isinstance(a,int) --->返回true
    isinstance(a,str) -->返回false

9)Python值常用操作符

+ - * / % **(幂运算) //(地板除法,结果偏小)
比较操作符 > < >= <=
逻辑操作符 and or not
   优先级:
     幂运算**
     正负号 + -
     算术操作符 * / //
         + -
     比较操作符 < > =
     逻辑擦作福 not and or

10)列表-->可以把整数、浮点数、字符串等打包在一起。数组却不能

创建一个普通列表:
   member = ['小甲鱼','小布丁','黑夜']
创建一个混合列表:
   mix=[1,'小甲鱼',3.12,[1,2,3]]
创建空列表:
   empty=[]
向列表添加元素:
   append(): member.append('福禄娃')-->只能添加一个。末尾添加
   extend(): member.extend(['test','test1'])-->只能以列表形式添加.末尾添加
   insert(): member.insert(1,'牡丹')-->第一位插入牡丹
列表中获取元素:使用索引index。    mix[1]
列表中删除元素:使用remove()。     mix.remove('小甲鱼')
           使用del。         del mix[3]/mix
           使用pop()。        mix.pop()/mix.pop(1)
列表切片:使用slice。 mix[1:4]/mix[1:]/mix[:4]
列表操作符:>,and,+,*,in/not in
列表的小伙伴:dir(list)
          mix.count('小甲鱼')
          mix.index('小甲鱼')
列表逆序:使用reverse。   mix.reverse()
列表排序:使用sort。     mix.sort()
       mix.sort(func,key)
       mix.sort(reverse=True)

11)元组--->不可改变的列表

和列表的主要不同点:
a)创建和访问一个元组: 大部分用()/, ;列表用[]
b)元组不可修改数值
c)更新和删除一个元组:temp = temp[:2] + ('test3',) + temp[2:]
  del temp
d)IN/NOT IN,关系操作符,逻辑操作符,乘号操作符,连接操作符

12)字符串的各种内置方法

str1='i love fishc.com'
a=str1[:6] + '插入的字符串'+str1[6:]
capitalize(): str2.capitalize()
casefold()--->全部小写 str2.casefold()
center(width)-->居中,不足空格填充
count(sub[,start[,end]])-->返回sub在string中出现的次数
endswith(sub[,start[,end]])-->以sub结束?
startswith(prefix[,start[,end]])-->以prefix开头
expandtabs([tabsize=8])-->将tab键转换为空格
find(sub[,start[,end]])-->sub是否在字符串中出现
rfind(sub)...
index(sub[,start[,end]])-->跟sub一样,不过会产生异常
rindex(sub..).....
istitle()/isupper()/ljust(width)/lower()/strip()/title()/lower()
join(sub):以字符串做分隔符,分割sub
partion(sub):找到子字符串sub,把字符串分成一个3元组
replace(old,new[,count])
split(sep=none,maxsplit=-1)-->不带参数以空格做分隔符
swapcase()-->字符串大小写翻转
zfill(width)-->返回长度为width的字符串,不够补充空格

13)字符串格式化 replacement

"{0} love {1}.{2:.2f}".format("i","fishc",3.1424)
"{a} love {b}.{c}".format(a="i",b="fishc",c="com")
"{0} love {b}.{c}".format("i",b="fishc",c="com")
格式化符号含义:
  %c:格式化字符及其ASCII码
  '%c %c %c' % (97,98,99)
  %s:格式化字符串
  %d:格式化整数
  %o:格式化无符号八进制数
  %x:格式化无符号十六进制数 %X:...(大写)
  %f:格式化定点数,可指定小数点后的精度
  %e:用科学技术发格式化定点数===%E
  %g:根据值的大小决定使用%f或%e===%G
格式化操作符辅助命令:
  m.n :m是显示的最小总宽度,n是小数位精度
  - :用于左对齐
  + :在正数面前添加正号
  # :在八进制面前显示0,在十六进制面前显示0x
  0 :空格用0填充
字符串转义字符
  \a:发出系统响铃声
  \b、\t、\n

14)序列

列表、元组和字符串的共同点:
  a)都可以通过索引
  b)索引值从零开始
内置方法:
   list()-->help-->转换为序列
     list()
       a=list()
     list(iterable)
       b='i love fishc.com'
       b=list(b)
   tuple([iterable])-->把一个可迭代对象转换为元组
       b=tuple(b)
   str(obj)-->把obj对象转换为字符串
   len(obj)-->返回obj的长度
   max(序列/元组) / min(序列/元组)
   sum(iterable[,start=0])-->返回序列iterable。。的总和
   sorted(序列/元组)-->排序
   reversed(序列/元组)-->返回一个迭代器对象
   list(reversed(序列/元组))-->返回序列
   enumerate(序列/元组)-->返回一个迭代器对象
   list(enumerate(序列/元组))-->返回数组形式列表
   zip(a,b)-->合并成以元组形式的列表
   list(zip(a,b))

15)函数

定义:def Myfunction():
   print('this is my first function')
调用:Myfunction()
函数的参数:
   def Myfunction(name,age):
   print(name+age+'test')
   Myfunction('gncao',‘age')
函数的返回值:
   return value
形参(parameter):函数定义时的参数
实参(argument):实际传递的参数
函数文档:在函数中实现
在函数体中用 '' 或 #
查看函数文档: a) functionname.__doc__ (四个下划线)
          b) help(functionname)
关键字参数:避免参数出乱
   def Myfunction(words,name):
   ......
   Myfunction(words='words123',name='name123')
 默认参数:
   def Myfunction(name='name123',words='words123')
   ......
 收集参数:在参数前面加上*号
  def test(*params):
  print('参数的长度是:',len(params))
  print('第二个参数是:',params[1])
  test(1,'小甲鱼',2,4,5,6,7) 

  def test(*params,exp):
  print('参数的长度是:',len(params),exp)
  print('第二个参数是:',params[1])
  test(1,'小甲鱼',23,4,2,5,7,exp=0)

16)函数有返回值,过程没有返回值

17)函数变量作用域(可见性)

局部:local-->函数内部定义的变量,局部可用
全局:global-->全局可访问
当在函数内部试图修改全局变量时,则会在函数内部新建一个跟 全局变量名相同的局部变量

18)内嵌函数和闭包

global关键字:
   def myfun():
     global count ->>>全局变量
     count=10
     print(count)
内嵌函数:
   def fun1():
     print('fun1()正在被调用...')
     def fun2():
        print('fun2()正在被调用')
     fun2()
只能通过fun1()访问fun2()
闭包:在一个内部函数中,对外部函数的变量的引用。成内部函数为闭包
   def funx(x):
     def funy(y):
       return x * y
     return funy
调用方式:
   i=funx(8)
   i(5)
   或
   funx(4)(5) 

通过关键字nonlocal可以使得内部函数调用外部函数变量。
   def fun1():
     x=5
     def fun2():
       nonlocal x
       x*=x
       return x
   return fun2()

19,递归:

recursion()
        def fac(n):
              if n==1:
                    return 1
              else:
                    return n*fac(n-1)
        number=int(input('请输入一个整数:'))
        result=fac(number)
        print('%d 的阶乘是:%d' % (number,result)) 

迭代方法:
def fab(n):
  n1=1
  n2=1
  n3=1 

  if n <1:
    print('输入有错')
    return -1
  while ( n-2>0 ):
    n3=n2+n1
    n1=n2
    n2=n3
    n-=1
  return n3 

result=fab(20)
if result != -1:
  print('总共有%d对小兔子诞生:' % result) 

递归方法:
def fab(n):
  if n < 1:
    print('error')
    return -1 

  if n==1 or n==2:
    return 1
  else:
    return fab(n-1) + fab(n-2) 

result=fab(20)
print('总共有%d对兔子诞生' % result) 

但是递归的效率比较低

20)字典(key-value)

映射/序列
例1:
dict1={'李宁':'一切皆有可能','耐克':'just do it','阿迪达斯':'impossible is nothing'} 

print('李宁的口号是:',dict1['李宁']) 

例2:
dict3=dict((('f',70),('i',105))) 

例3:
dict4=dict(小甲鱼='编程改变世界',test='test')
dict4['小甲鱼']='修改小甲鱼对应的value'   -->如果没有该KEY,则会自动添加一个KEY 

字典的内建方法:
a)
dict2['key']-->访问字典的元素
b)
fromkeys(s[,v]) -->创建或查询key
dict1.fromkeys((1,2,3))
{1: None, 2: None, 3: None}
dict1.fromkeys((1,2,3),'number')
{1: 'number', 2: 'number', 3: 'number'}
c)
keys()-->dict.keys() -->打印出dict的所有key
values()-->dict.values() -->打印出dict的所有value
items()-->dict.items() -->打印出dict所有(key,value)
get()--> dict.get(key) -->打印key对应的value
dict.get(key,'text')-->打印key对应的value,如果不存在,则打印text
in操作符 --> key in dict2
clear() -->dict.clear() -->清空dict的数据
copy() -->b=a.copy()  -->拷贝字典
id(a)-->查看id
pop(key) --> dict.pop(key) -->弹出key
popitem() -->dict.popitem() -->随机弹出key
setdefault() -->dict.setdefault(key) -->新建key
update()  -->dict.update(dict)  -->更新字典

21)集合 --->唯一性

num={1,2,3,4,5}
set()-->set1=set(列表/元组/字符串)
不支持索引
访问集合中的值:
    使用for循环一一查找
    使用IN 或者 NOT IN
add()-->set1.add(value)
remove()-->set1.remove(value)
不可变集合:
num3=frozenset(元组/列表)

22)文件

输入-->处理-->输出
内存--->磁盘
open()打开文件:
open('filename/path',mode='rwxabt+U') 

文件对象方法:
f.close() -->关闭文件
f.read(size=-1) -->从文件读取size个字符
f.readline() -->以写入模式打开,如果文件存在,则在末尾添加
f.write(str) -->将str写入文件
f.writelines(seq) ->向文件写入seq序列。seq应该是一个返回字符串序列
f.tell() -->返回当前的位置。书签
f.seek(offset,from) -->在文件中移动文件指针,从from偏移offset字节
for each in f:  ---->浏览整个文件
print(each)

23)文件系统

模块:打包的文件系统
os模块:
常用方法:
os.getcwd():返回工作目录
os.chdir(path):改变工作目录
os.listdir(path=''):列出文件目录
os.mkdir(path):创建目录
os.makedirs(path):创建递归目录
os.remove(path):删除文件
os.removedirs(path):递归删除
os.rename(old,new):文件重命名
os.system(command):运行系统的shell命令
os.curdir:指代当前目录.等价于‘。'
os.pardir:指代上一级目录
os.sep:输出操作系统的路径分隔符
os.linesep:当前平台使用的行终止符
os.name:指出当前使用的操作系统

24)永久存储

存放:pickling
读取:unpickling
首先要导入模块pickle
import pickle
>>> my_list=[1,2,3,'test',[23,43]]
>>> pickle_file=open('my_list.pkl','wb') --》打开一个pickle文件
>>> pickle.dump(my_list,pickle_file) --》把my_list导入到pickle_file
>>>pickle_file.close() 

>>> pickle_file=open('my_list.pkl','wb')
>>> my_list2=pickle.load(pickle_file) -->把pickle_file导入到my_list2

25)异常处理

常见标准异常:
AssertionErron/AttributeError/EOFError/IndexError/KeyError
/NameError/OSError/OverflowError/SyntaxError/TypeError/ZeroDivisionError

捕获异常:
try:
    检测范围
except Exception[as reason]:
    出现异常后的处理代码 print('代码')
except Exception[as reason];
    出现异常后的处理代码 print('daimai'+ str(reason))
except (Error1,Error2):
    处理异常的代码 

try:
    检测范围
except Exception[as reason]:
    处理异常的代码
finally:
    无论如何都会处理的代码 

raise语句抛出异常
raise Exception('指示代码')

26)丰富的else语句和简洁的with语句

else配合其他语句产生更多的功能
with语句:缩小工作量:
没有使用with前:
try:
  f=open('data.txt','r')
  for each in f:
    print(each)
except OSError as reason:
  print('出错啦:'+str(reason))
finally:
  f.close()
使用with后:
try:
  with open('data.txt','w') as f:
    for each in f:
      print(each)
except OSError as reason:
  print('出错啦:'+str(reason))
导入模块三种方式:
a)import  easygui
easygui.msgbox('test')
b)from easygui import *
msgbox('test')
c)import easygui as g
  g.msgbox('test') 

建议不要再IDLE上运行EASYGUI
关键词class
class Turtle:
    #属性
    color='green'
    weight=10
    #方法:
    def climb(self)
        print('climb tree') 

调用:
tt=Turtle() -->创建对象
tt.climb() -->调用方法 

oo=面向对象
oo的特征:
1,封装
2,继承
    class mylist(list):
        pass --->表示只继承父类,不做其他任何改动
    list2=mylist()
3,多态 

self-->相当于c++的this指针
>>> class ball:
    def setname(self,name):
        self.name=name
    def kick(self):
        print('i am %s,who kicked me????' % self.name)
a=ball()
a.setname('test') 

4,_init_(self) --->构造方法 

>>> class ball:
    def __init__(self,name):
        self.name=name
    def kick(self):
        print('i am %s,who kicked me????' % self.name)
b=ball('test') 

5,公有和私有 

类属性和方法默认都是公有的
name mangling --->名字改编,名字重整
私有变量:在变量名或函数名前加上'__'双下划线
访问私有变量方法:
1,在类内定义方法,间接访问私有变量
2,._类名__变量名 

6,继承
class derivedclassname(basename):
    ....
如果子类中出现和父类相同的方法,则覆盖掉父类的方法
不想覆盖掉父类的方法:
1,调用未绑定的父类方法
     def __init__(self):
        fish.__init__(self)  ----》先调用父类同名的方法
            self.hungry=True
2,使用super函数
     def __init__(self):
            super().__init__()
         self.hungry=True
7,多重继承
class derivedclass(base1,base2,base3):
    ...... 

8,拾遗
Mix-in编程机制 

类,类对象,实例对象,实例属性(static)
如果属性的名字和方法的名字相同,则属性会覆盖掉方法
绑定:
class bb:
    def printbb():
        print('no zuo no die')
b1=bb()
b1.printbb() ---->会出错误 

9,一些相关的BIF: 

issubclass(class,classinfo)
1,一个类被认为是自己的子类
2,classinfo可以是类对象组成的元祖,只要class与其中任何一个候选类的子类,则返回TRUE 

isinstance(object,classinfo)
检查对象是否属于classinfo类
1,如果第一个参数不是对象,则永远返回fasle
2,如果第二个不是类,则会抛出typeerror的异常 

hasattr(object,name) -->测定object中是否有'name‘属性
hasattr(c1,'x') 

getattr(object,name[,default]) -->如果有属性返回1,否则返回default 

setattr(object,name,value) -->给object中的name属性赋值vlalue 

delattr(object,name) -->删除object中的name属性 

property(fget=none,fset=none,fdel=none,doc=none)设置属性,设置定义好的属性
获取属性的方法,设置属性的方法,删除属性的方法
class c:
    def __init__(self,size=10):
        self.size=size
    def getsize(self):
        return self.size
    def setsize(self,value):
        self.size=value
    def delsize(self):
        del self.size
    x=property(getsize,setsize,delsize)
c1=c()
c1.x    /  c1.x=19   /c1.size

29)魔法方法(构造和析构)

特点:
1,魔法方法总是被双下划线包围,例如__init__
2,魔法方法是面向对象python的一切
3,魔法方法的魔力体现在他们总能够在适当的时候被自动调用 

构造方法: 

__init__(self[,...]) -->返回值一定是NONE
用在实例初始化 

__new__(cls[,...])  --->第一个初始化的方法
当继承一个不可修改属性的类时,则调用此方法修改属性
class capstr(str):
    def __new__(cls,string):
        string=string.upper()
        return str.__new__(cls,string) 

析构方法: 

__del__(self)  当数据不适用时,调用此方法
只有在调用了该对象的所有实例都消失时才会产生此方法

30)魔法方法:算术运算

__add__(self,other):定义加法的行为'+'
例子:
>>> class new_int(int):
    def __add__(self,other):
        return int.__sub__(self,other)
    def __sub__(self,other):
        return int.__add__(self,other) 

>>> a=new_int(3)
>>> b=new_int(8)
>>> a+b  ---->此时a是self,b是other
-5 

__sub__(sub,other):减法
__mul__(sub,other):乘法
truediv/floordiv/mod/divmod/pow/lshift/rshift/and/xor/or
divmod(a,b)返回的值是一个元祖:(a//b,a%b)

31)网络socket

socket提供较为底层的网络连接及数据传输功能
tcp socket/udp socket/unix socket 

整个通信过程三步走:
a)客户端连接服务器:
导入模块:
import socket
创建tcp类型的socket:
c=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
建立到指定ip地址、端口的tcp连接
c.connect(('211.121.12.43',80))
在系统上使用netstat命令查看新建的连接:
关闭连接:
c.close() 

b)服务器端监听:
import socket
s=socket.socket(socket.AF_INET,socket.sock.SOCK_STREAM)
s.bind(('127.0.0.1',80))
s.listen(1)
while True:
    cs,ca=s.accept() -->创建socket和客户端通信
    cs.sendall('replay')
    cs.close() 

c)客户端收发数据:
import socket
c=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
c.connect(('211.121.12.43',80))
向服务端发送‘hello'
c.send('hello')
读取服务端回复数据:
c.recv(1024)
c.close()

32)HTTP库实现HTTP协议

导入httplib模块:
import httplib
创建http实例,指定连接主机名和端口:
http=httplib.HTTPConnection('itercast.com',80)
指定要获取的URI:
http.request('GET','/ask') -->get方法获取指定数据,ask表示要访问的页面
输出返回的网页body内容:
print http.getresponse().read()
关闭连接:
http.close() 

更简单的urllib库:
导入urllib模块
import urllib
创建一个opener的实例
opener=urllib.build_opener()
打开指定的url
f=opener.open('http://www.baidu.com/ask')
读取返回内容
f.read()

33)python连接mysql的模块

import MySQLdb
conn=MySQLdb.connect(user='root',passwd='',host='127.0.0.1') --->连接mysql,默认是localhost
创建游标,通过游标发送sql指令
cur=conn.cursor()
conn.select_db('database-name') --》连接数据库,本例用week
cur.execute('insert into userinfo(name,age) value('milo',20)') --》执行sql语句。insert
简单化操作方式:
sqli='insert into userinfo(name,age,gender) value(%s,%s,%s)'
cur.execute(sqli,('a',37,'male'))
cur.executemany(sqli,[('test',34,'male'),('test2',36,'female')])
cur.execute('delete from userinfo where id=20') -->删除数据
cur.execute('select * from userinfo') -->查询数据,但是不能直接显示,使用以下方法可以查看
cur.fetchone()-->在python上显示一行数据
cur.scroll(0,'absolute')-->移动指标,此为绝对方式
cur.fetchmany(15)-->在python上显示15条数据.需要输入数据。必须先查询
cur.fetchmany(cur.execute('select * from userinfo')) -->通过一条命令显示数据
cur.close() -->关闭游标的连接
conn.close()  --->关闭数据库连接

以上这篇python常用知识梳理(必看篇)就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们。

28)类和对象

27)图形用户界面编程:EasyGui

(0)

相关推荐

  • Python进阶篇之字典操作总结

    一.与字典值有关的计算 问题 想对字典的值进行相关计算,例如找出字典里对应值最大(最小)的项. 解决方案一: 假设要从字典 {'a':3, 'b':2, 'c':6} 中找出值最小的项,可以这样做: >>> d = {'a':3, 'b':2, 'c':6} >>> min(zip(d.values(), d.keys())) (2, 'b') 值得注意的是  d.values() 获取字典的全部值,d.keys() 获取字典的全部键,而且两个序列的顺序依然保持一一对应

  • 总结Python编程中三条常用的技巧

    在 python 代码中可以看到一些常见的 trick,在这里做一个简单的小结. json 字符串格式化 在开发 web 应用的时候经常会用到 json 字符串,但是一段比较长的 json 字符串是可读性较差的,不容易看出来里面结构的. 这时候就可以用 python 来把 json 字符串漂亮的打印出来. root@Exp-1:/tmp# cat json.txt {"menu": {"breakfast": {"English Muffin":

  • 初学python的操作难点总结(新手必看篇)

    如下所示: 1 在cmd下 盘与盘之间的切换 直接 D或d: 就好 2 查找当前盘或者文件下面的目录 直接 dir 3 想在一个盘下进去一个文件夹,用cd空格目标文件 cd p 4 写文件的第一个字母后 按tab键自动补全 如果有多个p开头的则在按tab 会在所有之间切换 5 d:切盘 dir 查找目录 cd 进去目标文件(相当于双击) 6 往上走一层 cd .. 走两层 cd ../..(之间有无空格都行) 7 用python打开一个预先用记事本打好的txt 则先打开python f:\Dem

  • Python新手入门最容易犯的错误总结

    前言 Python 以其简单易懂的语法格式与其它语言形成鲜明对比,初学者遇到最多的问题就是不按照 Python 的规则来写,即便是有编程经验的程序员,也容易按照固有的思维和语法格式来写 Python 代码,之前小编给大家分享过了一篇<Python新手们容易犯的几个错误总结>,但总结的不够全面,最近看到有一个外国小伙总结了一些大家常犯的错误,16 Common Python Runtime Errors Beginners Find,索性我把他翻译过来并在原来的基础补充了我的一些理解,希望可以让

  • Python中字符串的常见操作技巧总结

    本文实例总结了Python中字符串的常见操作技巧.分享给大家供大家参考,具体如下: 反转一个字符串 >>> S = 'abcdefghijklmnop' >>> S[::-1] 'ponmlkjihgfedcba' 这种用法叫做three-limit slices 除此之外,还可以使用slice对象,例如 >>> 'spam'[slice(None, None, -1)] >>> unicode码与字符(single-characte

  • python常用知识梳理(必看篇)

    接触python已有一段时间了,下面针对python基础知识的使用做一完整梳理: 1)避免'\n'等特殊字符的两种方式: a)利用转义字符'\' b)利用原始字符'r' print r'c:\now' 2)单行注释,使用一个#,如: #hello Python 多行注释,使用三个单引号(或三个双引号),如: '''hello python hello world''' 或 """hello python hello world""" 另外跨越多行

  • java基础之数组常用操作总结(必看篇)

    常用的对数组进行的操作 1.求数组中最大值,最小值 思路:假设下标为0的元素是最大值,遍历数组,依次跟max进行比较,如果有元素比这个max还大,则把这个值赋给max.最小值同样 public class TestArray{ public static void main(String[] args){ int[] arr={23,45,234,576,34,87,34,12,67}; int max=arr[0]; int min=arr[0]; for(int i=0;i<arr.leng

  • jQuery 常用代码集锦(必看篇)

    1. 选择或者不选页面上全部复选框 var tog = false; // or true if they are checked on load $('a').click(function() { $("input[type=checkbox]").attr("checked",!tog); tog = !tog; }); 2. 取得鼠标的X和Y坐标 $(document).mousemove(function(e){ $(document).ready(func

  • Eclipse常用快捷键总结(必看篇)

    Alt+/                                内容辅助 最常用的快捷键,省去了自己一个字一个字敲代码的时间 Ctrl+Shift+F                        格式化文档 Ctrl+Shift+O                    批量导入包 Ctrl+t                                 打开类型树 Ctrl+鼠标左键 / F3              打开申明 查看代码的时候经常会用到 Alt+左箭头    

  • 新手如何快速入门Python(菜鸟必看篇)

    学习任何一门语言都是从入门(1年左右),通过不间断练习达到熟练水准(3到5年),少数人最终能精通语言,成为执牛耳者,他们是金字塔的最顶层.虽然万事开头难,但好的开始是成功的一半,今天这篇文章就来谈谈如何开始入门Python.只要方向对了,就不怕路远. 设定目标 当你决定入门 Python 时,需要一个清晰且短期内可实现的目标,比如通过学习找一份初级程序员工作,目标明确后,你需要了解企业对初级程序员有哪些技能要求,下面是我从拉勾网找的一个初级 Python 工程师的任职要求: 1.熟悉 Pytho

  • Python学习思维导图(必看篇)

    无意间碰到的一个大神整理的Python学习思维导图,感觉对初学者理清学习思路大有裨益,非常感谢他的分享. 14 张思维导图 基础知识 数据类型 序列 字符串 列表 & 元组 字典 & 集合 条件 & 循环 文件对象 错误 & 异常 函数 模块 面向对象编程 以上这篇Python学习思维导图(必看篇)就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们.

  • python数据处理实战(必看篇)

    一.运行环境 1.python版本 2.7.13 博客代码均是这个版本 2.系统环境:win7 64位系统 二.需求 对杂乱文本数据进行处理 部分数据截图如下,第一个字段是原字段,后面3个是清洗出的字段,从数据库中聚合字段观察,乍一看数据比较规律,类似(币种 金额 万元)这样,我想着用sql写条件判断,统一转换为'万元人民币' 单位,用sql脚本进行字符串截取即可完成,但是后面发现数据并不规则,条件判断太多清洗质量也不一定,有的前面不是左括号,有的字段里面没有币种,有的数字并不是整数,有的没有万

  • 老生常谈python的私有公有属性(必看篇)

    python中,类内方法外的变量叫属性,类内方法内的变量叫字段.他们的私有公有访问方法类似. class C: __name="私有属性" def func(self): print(C.__name) class sub_C(C): def info(self): print(C.__name)#派生类中不可以访问父类的私有字段 obj=C() obj.func() obj=sub_C() obj.info() 方法.属性的访问于上述方式相似,即:私有成员只能在类内部使用 以上这篇老

  • 常用Javascript函数与原型功能收藏(必看篇)

    如下所示: // 重复字符串 String.prototype.repeat = function(n) { return new Array(n+1).join(this); } // 替换全部 String.prototype.replaceAll = function(str1, str2) { return this.replace(new RegExp(str1, "gm"), str2); } // 清除空格 String.prototype.trim = function

随机推荐

其他