Python – Czit notes

FreeCAD: STL to STEP

przez kszyh | 16 grudnia 2015 - 10:35 |16 grudnia 2015 Lifehacking, Python

import sys                                                                                          
sys.path.insert(0, "E:\\Program Files\\FreeCAD 0.15\\bin")                                          
import FreeCAD                                                                                      
import Part                                                                                         
import Import                                                                                       
import Mesh                                                                                         
App.newDocument("Nienazwany")   
Mesh.insert(u"C:/Users/Krzysztof/Desktop/DANIEL/grain.stl","Nienazwany")
App.getDocument("Nienazwany").getObject("grain").harmonizeNormals()                                 
FreeCAD.getDocument("Nienazwany").addObject("Part::Feature","grain001")                                                                         
shape=Part.Shape()                                                                                  
shape.makeShapeFromMesh(FreeCAD.getDocument("Nienazwany").getObject("grain").Mesh.Topology,0.100000)
FreeCAD.getDocument("Nienazwany").getObject("grain001").Shape=shape                                 
FreeCAD.getDocument("Nienazwany").getObject("grain001").purgeTouched()                              
del shape                                                                                           
solids = []                                                                                         
solids.append(FreeCAD.getDocument("Nienazwany").getObject("grain001"))                              
Import.export(solids,u"C:/Users/Krzysztof/Desktop/DANIEL/grain_new.step")

import sys

sys.path.insert(0, "E:\\Program Files\\FreeCAD 0.15\\bin")

import FreeCAD

import Part

import Import

import Mesh

App.newDocument("Nienazwany")

Mesh.insert(u"C:/Users/Krzysztof/Desktop/DANIEL/grain.stl","Nienazwany")

App.getDocument("Nienazwany").getObject("grain").harmonizeNormals()

FreeCAD.getDocument("Nienazwany").addObject("Part::Feature","grain001")

shape=Part.Shape()

shape.makeShapeFromMesh(FreeCAD.getDocument("Nienazwany").getObject("grain").Mesh.Topology,0.100000)

FreeCAD.getDocument("Nienazwany").getObject("grain001").Shape=shape

FreeCAD.getDocument("Nienazwany").getObject("grain001").purgeTouched()

del shape

solids = []

solids.append(FreeCAD.getDocument("Nienazwany").getObject("grain001"))

Import.export(solids,u"C:/Users/Krzysztof/Desktop/DANIEL/grain_new.step")

Periodic boundary conditions in Abaqus (Periodyczne warunki brzegowe)

przez kszyh | 30 sierpnia 2015 - 16:53 |1 września 2015 Abaqus, Python

Dodaj komentarz

Założenia: zdefiniowane sety z węzłów na każdej krawędzi jako LEFT, RIGHT, TOP, BOTTOM i stworzone dwa punkty referencyjne w złożeniu oraz dwa sety z nimi o nazwach REF-PT-1 i REF-PT-2

# -*- coding: mbcs -*-
# Do not delete the following import lines
from abaqus import *
from abaqusConstants import *
import collections
import __main__


import section
import regionToolset
import displayGroupMdbToolset as dgm
import part
import material
import assembly
import optimization
import step
import interaction
import load
import mesh
import job
import sketch
import visualization
import xyPlot
import displayGroupOdbToolset as dgo
import connectorBehavior

modelName = 'COMPRESSION_XY'
periodicityLeftRight = True
periodicityBottomTop = True

#modelName = getInput('Enter model name:')

root = mdb.models[modelName].rootAssembly


# Clear all sets and equations connected to previous constaints
names = [set[0] for set in root.sets.items()]

for name in names:
    if "PERIOD-" in name:
        del root.sets[name] 


names = [c[0] for c in  mdb.models[modelName].constraints.items()]

for name in names:
    if "PERIOD-" in name:
        del  mdb.models[modelName].constraints[name] 

# Get nodes from edges. Sets need to be prepared before this step
leftSet = root.sets['LEFT'].nodes
rightSet = root.sets['RIGHT'].nodes
bottomSet = root.sets['BOTTOM'].nodes
topSet = root.sets['TOP'].nodes

# Connect Left to Right node
if periodicityLeftRight:
    idsLR = collections.OrderedDict()
    for nodeL in leftSet:
        for nodeR in rightSet:
            if nodeL.coordinates[1] == nodeR.coordinates[1]:
                idsLR[nodeL.label] = nodeR.label
        
    sortedLeft = tuple(idsLR.keys())
    sortedRight = tuple(idsLR.values())

# Connect Bottom to Top node
if periodicityBottomTop:
    idsBT = collections.OrderedDict()
    for nodeB in bottomSet:
        for nodeT in topSet:
            if nodeB.coordinates[0] == nodeT.coordinates[0]:
                idsBT[nodeB.label] = nodeT.label
        
    sortedBottom = tuple(idsBT.keys())
    sortedTop = tuple(idsBT.values())

i = 1
for n1, n2 in zip(sortedLeft, sortedRight):
    leftSetName = "PERIOD-LEFT"+str(i)
    rightSetName = "PERIOD-RIGHT"+str(i)
    
    root.SetFromNodeLabels(name=leftSetName, nodeLabels=(('PART-1-1', (n1,)), ))
    root.SetFromNodeLabels(name=rightSetName, nodeLabels=(('PART-1-1', (n2,)), ))
    eqName = "PERIOD-1-"+str(i)
    mdb.models[modelName].Equation(name=eqName, terms=((1.0, leftSetName, 1), (-1.0, rightSetName, 1), (1.0, 'REF-PT-1', 1), (0, 'REF-PT-1', 1)))
    # eqName = "PERIOD-2-"+str(i)
    # mdb.models[modelName].Equation(name=eqName, terms=((1.0, leftSetName, 2), (-1.0, rightSetName, 2), (1.0, 'REF-PT-2', 2), (0, 'REF-PT-2', 2)))
    i += 1
    
for n1, n2 in zip(sortedBottom, sortedTop):
    bottomSetName = "PERIOD-BOTTOM"+str(i)
    topSetName = "PERIOD-TOP"+str(i)
    root.SetFromNodeLabels(name=bottomSetName, nodeLabels=(('PART-1-1', (n1,)), ))
    root.SetFromNodeLabels(name=topSetName, nodeLabels=(('PART-1-1', (n2,)), ))
    eqName = "PERIOD-2-"+str(i)
    mdb.models[modelName].Equation(name=eqName, terms=((1.0, bottomSetName, 2), (-1.0, topSetName, 2), (1.0, 'REF-PT-2', 2), (0, 'REF-PT-2', 2)))
    # eqName = "PERIOD-1-"+str(i)
    # mdb.models[modelName].Equation(name=eqName, terms=((1.0, bottomSetName, 1), (-1.0, topSetName, 1), (1.0, 'REF-PT-1', 1), (0, 'REF-PT-1', 1)))
    i += 1

100

# -*- coding: mbcs -*-

# Do not delete the following import lines

from abaqus import *

from abaqusConstants import *

import collections

import __main__

import section

import regionToolset

import displayGroupMdbToolset as dgm

import part

import material

import assembly

import optimization

import step

import interaction

import load

import mesh

import job

import sketch

import visualization

import xyPlot

import displayGroupOdbToolset as dgo

import connectorBehavior

modelName = 'COMPRESSION_XY'

periodicityLeftRight = True

periodicityBottomTop = True

#modelName = getInput('Enter model name:')

root = mdb.models[modelName].rootAssembly

# Clear all sets and equations connected to previous constaints

names = [set[0] for set in root.sets.items()]

for name in names:

if "PERIOD-" in name:

del root.sets[name]

names = [c[0] for c in mdb.models[modelName].constraints.items()]

for name in names:

if "PERIOD-" in name:

del mdb.models[modelName].constraints[name]

# Get nodes from edges. Sets need to be prepared before this step

leftSet = root.sets['LEFT'].nodes

rightSet = root.sets['RIGHT'].nodes

bottomSet = root.sets['BOTTOM'].nodes

topSet = root.sets['TOP'].nodes

# Connect Left to Right node

if periodicityLeftRight:

idsLR = collections.OrderedDict()

for nodeL in leftSet:

for nodeR in rightSet:

if nodeL.coordinates[1] == nodeR.coordinates[1]:

idsLR[nodeL.label] = nodeR.label

sortedLeft = tuple(idsLR.keys())

sortedRight = tuple(idsLR.values())

# Connect Bottom to Top node

if periodicityBottomTop:

idsBT = collections.OrderedDict()

for nodeB in bottomSet:

for nodeT in topSet:

if nodeB.coordinates[0] == nodeT.coordinates[0]:

idsBT[nodeB.label] = nodeT.label

sortedBottom = tuple(idsBT.keys())

sortedTop = tuple(idsBT.values())

i = 1

for n1, n2 in zip(sortedLeft, sortedRight):

leftSetName = "PERIOD-LEFT"+str(i)

rightSetName = "PERIOD-RIGHT"+str(i)

root.SetFromNodeLabels(name=leftSetName, nodeLabels=(('PART-1-1', (n1,)), ))

root.SetFromNodeLabels(name=rightSetName, nodeLabels=(('PART-1-1', (n2,)), ))

eqName = "PERIOD-1-"+str(i)

mdb.models[modelName].Equation(name=eqName, terms=((1.0, leftSetName, 1), (-1.0, rightSetName, 1), (1.0, 'REF-PT-1', 1), (0, 'REF-PT-1', 1)))

# eqName = "PERIOD-2-"+str(i)

# mdb.models[modelName].Equation(name=eqName, terms=((1.0, leftSetName, 2), (-1.0, rightSetName, 2), (1.0, 'REF-PT-2', 2), (0, 'REF-PT-2', 2)))

i += 1

for n1, n2 in zip(sortedBottom, sortedTop):

bottomSetName = "PERIOD-BOTTOM"+str(i)

topSetName = "PERIOD-TOP"+str(i)

root.SetFromNodeLabels(name=bottomSetName, nodeLabels=(('PART-1-1', (n1,)), ))

root.SetFromNodeLabels(name=topSetName, nodeLabels=(('PART-1-1', (n2,)), ))

eqName = "PERIOD-2-"+str(i)

mdb.models[modelName].Equation(name=eqName, terms=((1.0, bottomSetName, 2), (-1.0, topSetName, 2), (1.0, 'REF-PT-2', 2), (0, 'REF-PT-2', 2)))

# eqName = "PERIOD-1-"+str(i)

# mdb.models[modelName].Equation(name=eqName, terms=((1.0, bottomSetName, 1), (-1.0, topSetName, 1), (1.0, 'REF-PT-1', 1), (0, 'REF-PT-1', 1)))

i += 1

Konwersja formatu macierzowego deal.ii na zgodny z Matlab

przez kszyh | 10 sierpnia 2015 - 10:47 |10 sierpnia 2015 C++, Linux, Python

Dodaj komentarz

Format wyjściowy biblioteki deal.ii

(0,0) 6.73636e-09
(0,1) 2.76187e-09
(0,2) -3.27721e-09
(0,3) -3.6236e-11
(0,4) 1.13877e-08
(0,5) -5.36419e-10

(0,0) 6.73636e-09

(0,1) 2.76187e-09

(0,2) -3.27721e-09

(0,3) -3.6236e-11

(0,4) 1.13877e-08

(0,5) -5.36419e-10

Matlab wymaga numeracji od 1 i linii ze spacjami zaraz przecinków:

1 1  6.73636e-09
1 2  2.76187e-09
1 3  -3.27721e-09
1 4  -3.6236e-11
1 5  1.13877e-08
1 6  -5.36419e-10

1 1 6.73636e-09

1 2 2.76187e-09

1 3 -3.27721e-09

1 4 -3.6236e-11

1 5 1.13877e-08

1 6 -5.36419e-10

Skrypt dokonujący konwersji:

#!/usr/bin/python
import sys
import re

with open(sys.argv[1]+".new", 'a+') as w:
    with open(sys.argv[1]) as file:
        for line in file:
            m = re.match(r'\((.*?),(.*?)\)(.*?)$', line)
            w.write('{0} {1} {2}\n'.format(int(m.group(1))+1, int(m.group(2))+1, m.group(3)))

#!/usr/bin/python

import sys

import re

with open(sys.argv[1]+".new", 'a+') as w:

with open(sys.argv[1]) as file:

for line in file:

m = re.match(r'$(.*?),(.*?)$(.*?)$', line)

w.write('{0} {1} {2}\n'.format(int(m.group(1))+1, int(m.group(2))+1, m.group(3)))

Uruchomienie:

./matrix_convert.py A.dat

1	./matrix_convert.py A.dat

Podpowiedzi składni w konsoli pythona

przez kszyh | 25 marca 2015 - 18:32 |25 marca 2015 Lifehacking, Python

Dodaj komentarz

Iron Python:

ipy -X:TabCompletion

1	ipy -X:TabCompletion

Python: Do .pythonrc

import rlcompleter, readline
readline.parse_and_bind('tab:complete')

1 2	import rlcompleter, readline readline.parse_and_bind('tab:complete')

export PYTHONSTARTUP=~/.pythonrc lub: echo „export PYTHONSTARTUP=~/.pythonrc” >> ~/.bashrc

Pobieranie największej wartości naprężenia i odkształcenia w Abaqusie

przez kszyh | 6 stycznia 2015 - 18:10 |6 stycznia 2015 Python

Dodaj komentarz

from abaqusConstants import *
from math import *
import odbAccess
import os
import multiprocessing as mp

################# CONFIGS #####################
odbFiles = ['MICRO_COMPR_XX', 'MICRO_COMPR_YY', 'MICRO_SHEAR_XY']  # seperate new odb files with comma
maxPercent = 0.0001                              # Percent of elements with maximum values which is taken to determinate average maximum value    
cpus = 4                                         # How many CPUs do you want to use - how many odbs will be accessed in the same time.      
###############################################

def avgMaxFromPercentList(l, percent, revSort):
    l.sort(reverse=revSort)   
    maxElements = int(ceil(len(l) * maxPercent))
    lmax = l[:maxElements]
    avg =  sum(lmax) / float(len(lmax))
    return avg


def Analise(resultFile):
    print resultFile + "\t[START]"

    try:
        os.remove(resultFile + '_MAX.txt')
    except OSError:
        pass
        
    odb = odbAccess.openOdb(resultFile+'.odb', readOnly=True)
    step=odb.steps['Step-1']

    frames = step.frames

    maxStrain = 0
    maxStress = 0
    # Stress/Strain Curve
    for frame in frames:
        # Max stress / strain 
        stress=frame.fieldOutputs['S'].getSubset(position=INTEGRATION_POINT).values
        strain=frame.fieldOutputs['PEEQ'].getSubset(position=INTEGRATION_POINT).values  
        
        count = len(stress)
        stressList = [None] * count
        strainList = [None] * count
        for i in range(0, count):
            stressList[i] = stress[i].mises      
            strainList[i] = strain[i].data   
     

        newStress = avgMaxFromPercentList(stressList, maxPercent, True)
        if newStress > maxStress:
            maxStress = newStress
            
        newStrain = avgMaxFromPercentList(strainList, maxPercent, True)
        if newStrain > maxStrain:
            maxStrain = newStrain
    
        
    file = open(resultFile+'_MAX.txt', 'w')
    file.write('{0}\t{1}\n'.format(maxStrain, maxStress))
    file.close()
    odb.close()
    
    print resultFile + "\t[DONE]"

    
if __name__ == '__main__': 
    pool = mp.Pool(processes=cpus)
    pool.map(Analise, odbFiles)
    pool.close() # no more tasks
    pool.join()  # wrap up current tasks
    
    print "Finished!"

from abaqusConstants import *

from math import *

import odbAccess

import os

import multiprocessing as mp

################# CONFIGS #####################

odbFiles = ['MICRO_COMPR_XX', 'MICRO_COMPR_YY', 'MICRO_SHEAR_XY'] # seperate new odb files with comma

maxPercent = 0.0001 # Percent of elements with maximum values which is taken to determinate average maximum value

cpus = 4 # How many CPUs do you want to use - how many odbs will be accessed in the same time.

###############################################

def avgMaxFromPercentList(l, percent, revSort):

l.sort(reverse=revSort)

maxElements = int(ceil(len(l) * maxPercent))

lmax = l[:maxElements]

avg = sum(lmax) / float(len(lmax))

return avg

def Analise(resultFile):

print resultFile + "\t[START]"

try:

os.remove(resultFile + '_MAX.txt')

except OSError:

pass

odb = odbAccess.openOdb(resultFile+'.odb', readOnly=True)

step=odb.steps['Step-1']

frames = step.frames

maxStrain = 0

maxStress = 0

# Stress/Strain Curve

for frame in frames:

# Max stress / strain

stress=frame.fieldOutputs['S'].getSubset(position=INTEGRATION_POINT).values

strain=frame.fieldOutputs['PEEQ'].getSubset(position=INTEGRATION_POINT).values

count = len(stress)

stressList = [None] * count

strainList = [None] * count

for i in range(0, count):

stressList[i] = stress[i].mises

strainList[i] = strain[i].data

newStress = avgMaxFromPercentList(stressList, maxPercent, True)

if newStress > maxStress:

maxStress = newStress

newStrain = avgMaxFromPercentList(strainList, maxPercent, True)

if newStrain > maxStrain:

maxStrain = newStrain

file = open(resultFile+'_MAX.txt', 'w')

file.write('{0}\t{1}\n'.format(maxStrain, maxStress))

file.close()

odb.close()

print resultFile + "\t[DONE]"

if __name__ == '__main__':

pool = mp.Pool(processes=cpus)

pool.map(Analise, odbFiles)

pool.close() # no more tasks

pool.join() # wrap up current tasks

print "Finished!"

Skrypt pobiera wartość maksymalną naprężeń Misesa i ekwiwalentnych odkształceń z n% elementów z największymi wartościami, wśród wszystkich kroków czasowych symulacji.

Pobieranie tensora naprężeń z pliku wynikowego Abaqusa

przez kszyh | 19 grudnia 2014 - 10:49 |19 grudnia 2014 Python, Skrypty

Dodaj komentarz

Skrypt pobiera tensor naprężeń z pliku wynikowego abaqusa a następnie tworzy krzywą odkształcenie/naprężenie. Skrypt działa równolegle Skrypt pobiera maksymalne wartości z ostatniego kroku obliczeń i zapisuje je do pliku

__author__ = "Krzysztof Bzowski"
__version__ = "1.0.0"


from abaqusConstants import *
from math import *
import odbAccess
import multiprocessing as mp
import os

################# CONFIGS #####################
odb11File = 'SSRVE_11'
odb12File = 'SSRVE_12'
odb22File = 'SSRVE_22'
maxPercent = 0.01
###############################################

def avgMaxFromPercentList(l, percent, revSort):
    l.sort(reverse=revSort)   
    maxElements = int(ceil(len(l) * maxPercent))
    lmax = l[:maxElements]
    avg =  sum(lmax) / float(len(lmax))
    return avg


def Analize(resultFile, direction, inOrder):
    try:
        os.remove(resultFile + '.txt')
    except OSError:
        pass
        
    try:
        os.remove(resultFile + '_MAX.txt')
    except OSError:
        pass
        
    odb = odbAccess.openOdb(resultFile+'.odb', readOnly=True)
    step=odb.steps['Step-1']

    frames = step.frames

    # Stress/Strain Curve
    for frame in frames:
        stress=frame.fieldOutputs['S'].getSubset(position=INTEGRATION_POINT).values
        strain=frame.fieldOutputs['PE'].getSubset(position=INTEGRATION_POINT).values
        volumes=frame.fieldOutputs['EVOL'].values
        
        count = len(volumes)
        summVol = 0
        summStress = 0
        summStrains = 0
        
        for i in range(0, count):
            s = stress[i].data[direction]       # S
            p = strain[i].data[direction]      # PE
            v = volumes[i].data      # VOLUME
            summVol += v
            summStress += s*v
            summStrains += p*v
            
        avgStress = summStress/summVol
        avgStrain = summStrains/summVol
        
        myFile = open(resultFile+'.txt', 'a')
        myFile.write('{0}\t{1}\n'.format(abs(avgStrain), abs(avgStress)))
        myFile.close()

    # Max stress / strain 
    lastFrame = frames[-1]
    stress=lastFrame.fieldOutputs['S'].getSubset(position=INTEGRATION_POINT).values
    strain=lastFrame.fieldOutputs['PE'].getSubset(position=INTEGRATION_POINT).values  
    count = len(stress)
    stressList = [None] * count
    strainList = [None] * count
    for i in range(0, count):
        stressList[i] = stress[i].data[direction]       # S
        strainList[i] = strain[i].data[direction]      # PE
 


    maxStress = avgMaxFromPercentList(stressList, maxPercent, inOrder)
    maxStrain = avgMaxFromPercentList(strainList, maxPercent, inOrder)
    file = open(resultFile+'_MAX.txt', 'w')
    file.write('{0}\t{1}\n'.format(maxStrain, maxStress))
    file.close()
    odb.close()
    
if __name__ == '__main__': 
    print __name__
    direction11 = 0
    direction22 = 1
    direction12 = 3
    
    p11 = mp.Process(target=Analize, args=(odb11File, direction11, False))
    p22 = mp.Process(target=Analize, args=(odb22File, direction22, False))
    p12 = mp.Process(target=Analize, args=(odb12File, direction12, True))

    p11.start()
    p22.start()
    p12.start()

    p11.join()
    p22.join()
    p12.join()

100

101

102

103

104

__author__ = "Krzysztof Bzowski"

__version__ = "1.0.0"

from abaqusConstants import *

from math import *

import odbAccess

import multiprocessing as mp

import os

################# CONFIGS #####################

odb11File = 'SSRVE_11'

odb12File = 'SSRVE_12'

odb22File = 'SSRVE_22'

maxPercent = 0.01

###############################################

def avgMaxFromPercentList(l, percent, revSort):

l.sort(reverse=revSort)

maxElements = int(ceil(len(l) * maxPercent))

lmax = l[:maxElements]

avg = sum(lmax) / float(len(lmax))

return avg

def Analize(resultFile, direction, inOrder):

try:

os.remove(resultFile + '.txt')

except OSError:

pass

try:

os.remove(resultFile + '_MAX.txt')

except OSError:

pass

odb = odbAccess.openOdb(resultFile+'.odb', readOnly=True)

step=odb.steps['Step-1']

frames = step.frames

# Stress/Strain Curve

for frame in frames:

stress=frame.fieldOutputs['S'].getSubset(position=INTEGRATION_POINT).values

strain=frame.fieldOutputs['PE'].getSubset(position=INTEGRATION_POINT).values

volumes=frame.fieldOutputs['EVOL'].values

count = len(volumes)

summVol = 0

summStress = 0

summStrains = 0

for i in range(0, count):

s = stress[i].data[direction] # S

p = strain[i].data[direction] # PE

v = volumes[i].data # VOLUME

summVol += v

summStress += s*v

summStrains += p*v

avgStress = summStress/summVol

avgStrain = summStrains/summVol

myFile = open(resultFile+'.txt', 'a')

myFile.write('{0}\t{1}\n'.format(abs(avgStrain), abs(avgStress)))

myFile.close()

# Max stress / strain

lastFrame = frames[-1]

stress=lastFrame.fieldOutputs['S'].getSubset(position=INTEGRATION_POINT).values

strain=lastFrame.fieldOutputs['PE'].getSubset(position=INTEGRATION_POINT).values

count = len(stress)

stressList = [None] * count

strainList = [None] * count

for i in range(0, count):

stressList[i] = stress[i].data[direction] # S

strainList[i] = strain[i].data[direction] # PE

maxStress = avgMaxFromPercentList(stressList, maxPercent, inOrder)

maxStrain = avgMaxFromPercentList(strainList, maxPercent, inOrder)

file = open(resultFile+'_MAX.txt', 'w')

file.write('{0}\t{1}\n'.format(maxStrain, maxStress))

file.close()

odb.close()

if __name__ == '__main__':

print __name__

direction11 = 0

direction22 = 1

direction12 = 3

p11 = mp.Process(target=Analize, args=(odb11File, direction11, False))

p22 = mp.Process(target=Analize, args=(odb22File, direction22, False))

p12 = mp.Process(target=Analize, args=(odb12File, direction12, True))

p11.start()

p22.start()

p12.start()

p11.join()

p22.join()

p12.join()

Łączenie dużej ilości obiektów String w Pythonie 2.6

przez kszyh | 6 października 2014 - 07:57 |6 października 2014 Python

Dodaj komentarz

from cStringIO import StringIO
from UserString import MutableString
import time
max = 100000
print "Benchmarking ", max, " string concatenations."

start = time.time()
buf1 = StringIO()
for i in range(1,max):
    buf1.write(str(i))
end = time.time()
print "StringIO write():\t", end - start

start = time.time()
buf2 = MutableString()
for i in range(1,max):
    buf2 += str(i)
end = time.time()
print "MutableString +=:\t", end - start 


start = time.time()
buf3 = ""
for i in range(1,max):
    buf3 += str(i)
end = time.time()    
print "String +=:\t\t", end - start


start = time.time()
buf4 = MutableString()
for i in range(1,max):
    buf4.append(str(i))
end = time.time()
print "MutableString Append():\t", end - start 
 
start = time.time()
buf5 = ''.join([`num` for num in xrange(max)])
end = time.time()
print "String join():\t\t", end - start

from cStringIO import StringIO

from UserString import MutableString

import time

max = 100000

print "Benchmarking ", max, " string concatenations."

start = time.time()

buf1 = StringIO()

for i in range(1,max):

buf1.write(str(i))

end = time.time()

print "StringIO write():\t", end - start

start = time.time()

buf2 = MutableString()

for i in range(1,max):

buf2 += str(i)

end = time.time()

print "MutableString +=:\t", end - start

start = time.time()

buf3 = ""

for i in range(1,max):

buf3 += str(i)

end = time.time()

print "String +=:\t\t", end - start

start = time.time()

buf4 = MutableString()

for i in range(1,max):

buf4.append(str(i))

end = time.time()

print "MutableString Append():\t", end - start

start = time.time()

buf5 = ''.join([`num` for num in xrange(max)])

end = time.time()

print "String join():\t\t", end - start

Benchmarking  100000  string concatenations.
StringIO write():        0.0330123901367
MutableString +=:        23.9283676147
String +=:               25.2034454346
MutableString Append():  25.2694396973
String join():           0.0279998779297

Benchmarking 100000 string concatenations.

StringIO write(): 0.0330123901367

MutableString +=: 23.9283676147

String +=: 25.2034454346

MutableString Append(): 25.2694396973

String join(): 0.0279998779297

Archiwum kategorii: Python

FreeCAD: STL to STEP

Periodic boundary conditions in Abaqus (Periodyczne warunki brzegowe)

Konwersja formatu macierzowego deal.ii na zgodny z Matlab

Podpowiedzi składni w konsoli pythona

Pobieranie największej wartości naprężenia i odkształcenia w Abaqusie

Pobieranie tensora naprężeń z pliku wynikowego Abaqusa

Łączenie dużej ilości obiektów String w Pythonie 2.6

Ostatnie wpisy

Najnowsze komentarze

Kategorie

Meta